libmceliece-20230612/0000755000000000000000000000000014441554511012712 5ustar rootrootlibmceliece-20230612/Makefile0000644000000000000000000000015014441554466014357 0ustar rootrootdefault: cd build && $(MAKE) install: cd build && $(MAKE) install clean: cd build && $(MAKE) clean libmceliece-20230612/api0000644000000000000000000001627414441554466013431 0ustar rootrootcrypto_xof/shake256 a3c4908bf4412d650a1f0a69587778b72aeea66db5a9991a4f0cf2d782ca65b9 27d81315afb30a84e66c5cc70700b5087142e5748a3b50392f28758148c40644 void crypto_xof(unsigned char *,long long,const unsigned char *,long long); crypto_sort/int32 3458da92fdba9924c019db57dd7079f7613df0e243f3b312d10d94781af8c29a 7265f7d8ed54b4a3bd12db9648e246615363373e7044c8d1b7c789ebfc177629 #define crypto_sort_int32_BYTES 4 void crypto_sort(void *,long long); crypto_kem/6960119 008c0538526a1c037e64f0543628b312a71e879c1f882f65493fd0d3a225d5d8 15c6727d4f4867487a54bbb208c06c1142a56a7937d7b598c05f63801cbdd277 #define crypto_kem_6960119_PUBLICKEYBYTES 1047319 #define crypto_kem_6960119_SECRETKEYBYTES 13948 #define crypto_kem_6960119_CIPHERTEXTBYTES 194 #define crypto_kem_6960119_BYTES 32 crypto_kem/6960119f 8d0f85c0ffa074aff7cf1c5d2f8a048174de4ee62a74556e04e8da326e8b640d d62841358b16796439c261003bae87733ef9889374061bce0a261f80b072861f #define crypto_kem_6960119f_PUBLICKEYBYTES 1047319 #define crypto_kem_6960119f_SECRETKEYBYTES 13948 #define crypto_kem_6960119f_CIPHERTEXTBYTES 194 #define crypto_kem_6960119f_BYTES 32 crypto_kem/6960119pc f164d7a16ea6175870f34056b211d4d45a2bc95085759e2f688721f3fbf326c8 7f2438a79d20ae3b056f2d13bca43ea7c1ba2a2e0535cc35f7016188910a4720 #define crypto_kem_6960119pc_PUBLICKEYBYTES 1047319 #define crypto_kem_6960119pc_SECRETKEYBYTES 13948 #define crypto_kem_6960119pc_CIPHERTEXTBYTES 226 #define crypto_kem_6960119pc_BYTES 32 crypto_kem/6960119pcf 873616887e3e83679d5a708b3fbd8eb2301d18ea21f0f7c238db87178596267a d709f666d84fe4450ec59759ef20982df8d614afe788db2b7d0f91b0c0e02254 #define crypto_kem_6960119pcf_PUBLICKEYBYTES 1047319 #define crypto_kem_6960119pcf_SECRETKEYBYTES 13948 #define crypto_kem_6960119pcf_CIPHERTEXTBYTES 226 #define crypto_kem_6960119pcf_BYTES 32 crypto_kem/6688128 a3446acecf9aff0e757dfafc5402e365eb3ba485dd1f7b052f3ca6eabfdcb6c4 b2ee78aaa23c0612155239b1d92e9e1af589cb810bdb9d8c44eb85dbfd2e46d4 #define crypto_kem_6688128_PUBLICKEYBYTES 1044992 #define crypto_kem_6688128_SECRETKEYBYTES 13932 #define crypto_kem_6688128_CIPHERTEXTBYTES 208 #define crypto_kem_6688128_BYTES 32 crypto_kem/6688128f daec95f7a2db91986d2d1ca7312d66314149b066db0f467935ecf027aa1f4403 a371ae9485120c1ea108b85723470e5b317ca4428fa01a27b3b5f33f5d924d32 #define crypto_kem_6688128f_PUBLICKEYBYTES 1044992 #define crypto_kem_6688128f_SECRETKEYBYTES 13932 #define crypto_kem_6688128f_CIPHERTEXTBYTES 208 #define crypto_kem_6688128f_BYTES 32 crypto_kem/6688128pc f6d44759e9e52330923b5dc2957cd080c10b31990a96e0540c52ba42017fa849 53e96db3d38fe59717c537c269eddb0474e0548e964d2fbfbc1082ef03e68857 #define crypto_kem_6688128pc_PUBLICKEYBYTES 1044992 #define crypto_kem_6688128pc_SECRETKEYBYTES 13932 #define crypto_kem_6688128pc_CIPHERTEXTBYTES 240 #define crypto_kem_6688128pc_BYTES 32 crypto_kem/6688128pcf 80e0655938457c4dcd6aa6323d60f2495efda8a2d4a13b1958e8ca8fd2e848b6 a4451d736f136a43032cd4d1047b4b7494ee6d0c91d75deff011e596bdb1b3ec #define crypto_kem_6688128pcf_PUBLICKEYBYTES 1044992 #define crypto_kem_6688128pcf_SECRETKEYBYTES 13932 #define crypto_kem_6688128pcf_CIPHERTEXTBYTES 240 #define crypto_kem_6688128pcf_BYTES 32 crypto_kem/8192128 debad73db5027e8239b7e97d04c5a98b7521caba8ea4e58581c90efb50dd4b9e 5e64e0aeb5ab566a1efbb2b1127dcbf909ee1b395945f066cd5f097a85f2e135 #define crypto_kem_8192128_PUBLICKEYBYTES 1357824 #define crypto_kem_8192128_SECRETKEYBYTES 14120 #define crypto_kem_8192128_CIPHERTEXTBYTES 208 #define crypto_kem_8192128_BYTES 32 crypto_kem/8192128f 2d50dd3ea54c764b5f79505d181c08cefc2276a28c791681cce3a45888c687cc 717835d0cdf7f4e9a36a53d93116028be3ba3eb7f57bf4913303f3c2e1830900 #define crypto_kem_8192128f_PUBLICKEYBYTES 1357824 #define crypto_kem_8192128f_SECRETKEYBYTES 14120 #define crypto_kem_8192128f_CIPHERTEXTBYTES 208 #define crypto_kem_8192128f_BYTES 32 crypto_kem/8192128pc a9d56a17b9b870e832cddde5c5787b55ada2189992d03eb75e23e710bcb98ccd ac060fe5c1bdb9bd96bfa21ad4875cacb61f8e4eed791511020db06c65909811 #define crypto_kem_8192128pc_PUBLICKEYBYTES 1357824 #define crypto_kem_8192128pc_SECRETKEYBYTES 14120 #define crypto_kem_8192128pc_CIPHERTEXTBYTES 240 #define crypto_kem_8192128pc_BYTES 32 crypto_kem/8192128pcf fdf47ca26ac3e1a3ae8c2859619cce789420a4af8533ded9e1104d232bd62f5e 182ec5f02250b7764c121a1b481ec6003c0897f7d772ae7d0bba226660bb99e4 #define crypto_kem_8192128pcf_PUBLICKEYBYTES 1357824 #define crypto_kem_8192128pcf_SECRETKEYBYTES 14120 #define crypto_kem_8192128pcf_CIPHERTEXTBYTES 240 #define crypto_kem_8192128pcf_BYTES 32 crypto_kem/460896 006c110df7fd3ff1852c9096a6514855ef3e715469ecc21d5b6ba14d31057417 604d5d0be1ec220a2a914735fa5469622cd1f66737cf7e0709b7eaaa1e382f66 #define crypto_kem_460896_PUBLICKEYBYTES 524160 #define crypto_kem_460896_SECRETKEYBYTES 13608 #define crypto_kem_460896_CIPHERTEXTBYTES 156 #define crypto_kem_460896_BYTES 32 crypto_kem/460896f 1418b90ac6aa9d36bd3c42c7e8c4ba299eafa45e93a903a383041629fb47f043 863b850af9436f66906c5824c32165b512352f398f32b2933c424bac34dcdd23 #define crypto_kem_460896f_PUBLICKEYBYTES 524160 #define crypto_kem_460896f_SECRETKEYBYTES 13608 #define crypto_kem_460896f_CIPHERTEXTBYTES 156 #define crypto_kem_460896f_BYTES 32 crypto_kem/460896pc e27bb3f53c37eaaef460488d21750a80baf3874b0b26b23e510325e45c31c560 99fe694290b1e02673ad7f1b69ce51aa94406ba23cdf77e69012f0b2fbcebaba #define crypto_kem_460896pc_PUBLICKEYBYTES 524160 #define crypto_kem_460896pc_SECRETKEYBYTES 13608 #define crypto_kem_460896pc_CIPHERTEXTBYTES 188 #define crypto_kem_460896pc_BYTES 32 crypto_kem/460896pcf 1980e3f38d8258eca9d8d4300ac8dd6a6cde2f2c10c5e7b589971972531c8505 063a2ecf26e027499a9f6b4e8344800819c28bf094926af1e3ec45107175ce53 #define crypto_kem_460896pcf_PUBLICKEYBYTES 524160 #define crypto_kem_460896pcf_SECRETKEYBYTES 13608 #define crypto_kem_460896pcf_CIPHERTEXTBYTES 188 #define crypto_kem_460896pcf_BYTES 32 crypto_kem/348864 2f36e1825115c5accc9a6ea609dec708f83be85e7fe448637bd502de50a1dd91 df7965299cab8d4669eb29ebe87a2f61a539aa016a8dcda268a8cd595bf6d8da #define crypto_kem_348864_PUBLICKEYBYTES 261120 #define crypto_kem_348864_SECRETKEYBYTES 6492 #define crypto_kem_348864_CIPHERTEXTBYTES 96 #define crypto_kem_348864_BYTES 32 crypto_kem/348864f 5ad76eff6b5ccaedc1615e9795880cfd79b44c4247db4b8a13684c507a5db437 471a096310df17d7650c5d1a2e798909598b3b16652c70eb722be84673cf2f8f #define crypto_kem_348864f_PUBLICKEYBYTES 261120 #define crypto_kem_348864f_SECRETKEYBYTES 6492 #define crypto_kem_348864f_CIPHERTEXTBYTES 96 #define crypto_kem_348864f_BYTES 32 crypto_kem/348864pc ddfa65df30bee9c97e153089d24cce158a7979aa01ebdbb7bf374da13bd81feb 9866af598e967b1b3903d9e125bf756a92aed474f750678238b2bb52129cd213 #define crypto_kem_348864pc_PUBLICKEYBYTES 261120 #define crypto_kem_348864pc_SECRETKEYBYTES 6492 #define crypto_kem_348864pc_CIPHERTEXTBYTES 128 #define crypto_kem_348864pc_BYTES 32 crypto_kem/348864pcf 4dcfc56d5e162873f227befd1e7c51f2b317f9ccf811e931e86e2fcdeea6c10e 48fffebf6cd92a688b4724d88cf989ab199066040c7c62202dab6f30ef188d68 #define crypto_kem_348864pcf_PUBLICKEYBYTES 261120 #define crypto_kem_348864pcf_SECRETKEYBYTES 6492 #define crypto_kem_348864pcf_CIPHERTEXTBYTES 128 #define crypto_kem_348864pcf_BYTES 32 void crypto_kem_keypair(unsigned char *,unsigned char *); int crypto_kem_enc(unsigned char *,unsigned char *,const unsigned char *); int crypto_kem_dec(unsigned char *,const unsigned char *,const unsigned char *); libmceliece-20230612/autogen/0000755000000000000000000000000014441554466014365 5ustar rootrootlibmceliece-20230612/autogen/cli0000755000000000000000000001216314441554466015065 0ustar rootroot#!/usr/bin/env python3 import re keypair = r'''#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[PRIMITIVE_PUBLICKEYBYTES]; static unsigned char sk[PRIMITIVE_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"PRIMITIVE-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"PRIMITIVE-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"PRIMITIVE-keypair: usage: PRIMITIVE-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"PRIMITIVE-keypair: usage: PRIMITIVE-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } PRIMITIVE_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } ''' enc = r'''#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[PRIMITIVE_PUBLICKEYBYTES]; static unsigned char c[PRIMITIVE_CIPHERTEXTBYTES]; static unsigned char k[PRIMITIVE_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"PRIMITIVE-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"PRIMITIVE-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"PRIMITIVE-enc: usage: PRIMITIVE-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[PRIMITIVE_SECRETKEYBYTES]; static unsigned char c[PRIMITIVE_CIPHERTEXTBYTES]; static unsigned char k[PRIMITIVE_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"PRIMITIVE-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"PRIMITIVE-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"PRIMITIVE-dec: usage: PRIMITIVE-dec 7>sessionkey sessionkey libmceliece-20230612/autogen/html-title0000644000000000000000000000001414441554466016366 0ustar rootrootlibmceliece libmceliece-20230612/autogen/man0000755000000000000000000000206114441554466015065 0ustar rootroot#!/bin/sh mkdir -p doc/man pandoc --standalone --to man --metadata title=mceliece --metadata section=3 < doc/api.md | sed 's/^ //' > doc/man/mceliece.3 for size in 6960119 6688128 8192128 460896 348864 do for param in "$size" "$size"f "$size"pc "$size"pcf do for manpage in "$param" "$param"_keypair "$param"_enc "$param"_dec do rm -f doc/man/mceliece"$manpage".3 ln -s mceliece.3 doc/man/mceliece"$manpage".3 done done done pandoc --standalone --to man --metadata title=mceliece --metadata section=1 < doc/cli.md | sed 's/^ //' > doc/man/mceliece.1 for size in 6960119 6688128 8192128 460896 348864 do for param in "$size" "$size"pc do for manpage in "$param" "$param"-keypair "$param"-enc "$param"-dec do rm -f doc/man/mceliece"$manpage".1 ln -s mceliece.1 doc/man/mceliece"$manpage".1 done done for param in "$size"f "$size"pcf do for manpage in "$param" "$param"-keypair do rm -f doc/man/mceliece"$manpage".1 ln -s mceliece.1 doc/man/mceliece"$manpage".1 done done done libmceliece-20230612/autogen/speed0000755000000000000000000002064314441554466015420 0ustar rootroot#!/usr/bin/env python3 output = r'''/* WARNING: auto-generated (by autogen-speed); do not edit */ #include #include #include #include #include #include #include #include #include /* -lcpucycles */ #include /* -lmceliece */ #include /* -lrandombytes */ static const char *targeto = 0; static const char *targetp = 0; static const char *targeti = 0; #include "limits.inc" static void *callocplus(long long len) { void *x = calloc(1,len + 128); if (!x) abort(); return x; } static void *aligned(void *x) { unsigned char *y = x; y += 63 & (-(unsigned long) x); return y; } #define TIMINGS 15 static long long t[TIMINGS+1]; static void t_print(const char *op,long long impl,long long len) { long long median = 0; printf("%s",op); if (impl >= 0) printf(" %lld",impl); else printf(" selected"); printf(" %lld",len); for (long long i = 0;i < TIMINGS;++i) t[i] = t[i+1]-t[i]; for (long long j = 0;j < TIMINGS;++j) { long long belowj = 0; long long abovej = 0; for (long long i = 0;i < TIMINGS;++i) if (t[i] < t[j]) ++belowj; for (long long i = 0;i < TIMINGS;++i) if (t[i] > t[j]) ++abovej; if (belowj*2 < TIMINGS && abovej*2 < TIMINGS) { median = t[j]; break; } } printf(" %lld ",median); for (long long i = 0;i < TIMINGS;++i) printf("%+lld",t[i]-median); printf("\n"); fflush(stdout); } #define MAXTEST_BYTES 65536 static void measure_cpucycles(void) { printf("cpucycles selected persecond %lld\n",cpucycles_persecond()); printf("cpucycles selected implementation %s\n",cpucycles_implementation()); for (long long i = 0;i <= TIMINGS;++i) t[i] = cpucycles(); t_print("cpucycles",-1,0); } static void measure_randombytes(void) { void *mstorage = callocplus(MAXTEST_BYTES); unsigned char *m = aligned(mstorage); long long mlen = 0; while (mlen < MAXTEST_BYTES) { for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); randombytes(m,mlen); } t_print("randombytes",-1,mlen); mlen += 1+mlen/2; } free(mstorage); } ''' # XXX: integrate todo into api todo = ( ('sort',( ('m','MAXTEST_BYTES'), ('mlen',None), ),( ('crypto_sort','m','mlen'), )), ('xof',( ('h','MAXTEST_BYTES'), ('hlen',None), ('m','MAXTEST_BYTES'), ('mlen',None), ),( ('crypto_xof','h','hlen','m','mlen'), )), ('kem',( ('p','mceliece_kem_PUBLICKEYBYTES'), ('s','mceliece_kem_SECRETKEYBYTES'), ('c','mceliece_kem_CIPHERTEXTBYTES'), ('k','mceliece_kem_BYTES'), ('T','mceliece_kem_CIPHERTEXTBYTES'), ),( ('crypto_kem_keypair','p','s'), ('crypto_kem_enc','c','k','p'), ('crypto_kem_dec','T','c','s'), )), ) operations = [] primitives = {} sizes = {} exports = {} prototypes = {} with open('api') as f: for line in f: line = line.strip() if line.startswith('crypto_'): x = line.split() x = x[0].split('/') assert len(x) == 2 o = x[0].split('_')[1] if o not in operations: operations += [o] p = x[1] if o not in primitives: primitives[o] = [] primitives[o] += [p] continue if line.startswith('#define '): x = line.split(' ') x = x[1].split('_') assert len(x) == 4 assert x[0] == 'crypto' o = x[1] p = x[2] if (o,p) not in sizes: sizes[o,p] = '' sizes[o,p] += line+'\n' continue if line.endswith(');'): fun,args = line[:-2].split('(') rettype,fun = fun.split() fun = fun.split('_') o = fun[1] assert fun[0] == 'crypto' if o not in exports: exports[o] = [] exports[o] += ['_'.join(fun[1:])] if o not in prototypes: prototypes[o] = [] prototypes[o] += [(rettype,fun,args)] for t in todo: o,vars,benches = t for p in primitives[o]: output += '\n' output += 'static void measure_%s_%s(void)\n' % (o,p) output += '{\n' output += ' if (targeto && strcmp(targeto,"%s")) return;\n' % o output += ' if (targetp && strcmp(targetp,"%s")) return;\n' % p varsize = {} for v,size in vars: if size is None: output += ' long long %s;\n' % v else: size = size.replace('mceliece_'+o,'mceliece_'+o+'_'+p) output += ' void *%sstorage = callocplus(%s);\n' % (v,size) output += ' unsigned char *%s = aligned(%sstorage);\n' % (v,v) varsize[v] = size output += '\n' output += ' for (long long impl = -1;impl < mceliece_numimpl_%s_%s();++impl) {\n' % (o,p) for rettype,fun,args in prototypes[o]: output += ' %s (*%s)(%s);\n' % (rettype,'_'.join(fun),args) output += ' if (targeti && strcmp(targeti,mceliece_dispatch_%s_%s_implementation(impl))) continue;\n' % (o,p) output += ' if (impl >= 0) {\n' for rettype,fun,args in prototypes[o]: f2 = ['mceliece','dispatch',o,p]+fun[2:] output += ' %s = %s(impl);\n' % ('_'.join(fun),'_'.join(f2)) output += r' printf("%s_%s %%lld implementation %%s compiler %%s\n",impl,mceliece_dispatch_%s_%s_implementation(impl),mceliece_dispatch_%s_%s_compiler(impl));' % (o,p,o,p,o,p) output += '\n' output += ' } else {\n' for rettype,fun,args in prototypes[o]: f2 = ['mceliece',o,p]+fun[2:] output += ' %s = %s;\n' % ('_'.join(fun),'_'.join(f2)) output += r' printf("%s_%s selected implementation %%s compiler %%s\n",mceliece_%s_%s_implementation(),mceliece_%s_%s_compiler());' % (o,p,o,p,o,p) output += '\n' output += ' }\n' for v,size in vars: if size is not None: size = size.replace('mceliece_'+o,'mceliece_'+o+'_'+p) output += ' randombytes(%s,%s);\n' % (v,size) alreadybenched = set() alreadybenched.add('assert') for b in benches: if b[0] in alreadybenched: output += ' %s(%s);\n' % (b[0],','.join(b[1:])) continue fun = b[0].split('_') shortfun = '_'.join([o,p]+fun[2:]) alreadybenched.add(b[0]) if 'mlen' in b[1:]: if b[0] == 'crypto_xof': output += ' hlen = 32;\n' output += ' mlen = 0;\n' if b[0] == 'crypto_sort': output += ' while (mceliece_%s_%s_BYTES*mlen <= MAXTEST_BYTES) {\n' % (o,p) output += ' randombytes(m,mceliece_%s_%s_BYTES*mlen);\n' % (o,p) else: output += ' while (mlen <= MAXTEST_BYTES) {\n' output += ' randombytes(m,mlen);\n' output += ' for (long long i = 0;i <= TIMINGS;++i) {\n' output += ' t[i] = cpucycles();\n' output += ' %s(%s);\n' % (b[0],','.join(b[1:])) output += ' }\n' output += ' t_print("%s",impl,mlen);\n' % (shortfun) output += ' mlen += 1+mlen/2;\n' output += ' }\n' else: output += ' for (long long i = 0;i <= TIMINGS;++i) {\n' output += ' t[i] = cpucycles();\n' output += ' %s(%s);\n' % (b[0],','.join(b[1:])) output += ' }\n' output += ' t_print("%s",impl,%s);\n' % (shortfun,varsize[b[1]]) if 'hlen' in b[1:]: if b[0] == 'crypto_xof': output += ' mlen = 32;\n' output += ' hlen = 1;\n' output += ' while (hlen <= MAXTEST_BYTES) {\n' output += ' randombytes(h,hlen);\n' output += ' for (long long i = 0;i <= TIMINGS;++i) {\n' output += ' t[i] = cpucycles();\n' output += ' %s(%s);\n' % (b[0],','.join(b[1:])) output += ' }\n' output += ' t_print("%s",impl,-hlen);\n' % (shortfun) output += ' hlen += 1+hlen/2;\n' output += ' }\n' output += ' }\n' for v,size in reversed(vars): if size is not None: output += ' free(%sstorage);\n' % v output += '}\n' output += r''' #include "print_cpuid.inc" int main(int argc,char **argv) { printf("mceliece version %s\n",mceliece_version); printf("mceliece arch %s\n",mceliece_arch); print_cpuid(); if (*argv) ++argv; if (*argv) { targeto = *argv++; if (*argv) { targetp = *argv++; if (*argv) { targeti = *argv++; } } } measure_cpucycles(); measure_randombytes(); limits(); ''' for t in todo: o,vars,benches = t for p in primitives[o]: output += ' measure_%s_%s();\n' % (o,p) output += r''' return 0; } ''' with open('command/mceliece-speed.c','w') as f: f.write(output) libmceliece-20230612/autogen/test0000755000000000000000000006102214441554466015273 0ustar rootroot#!/usr/bin/env python3 import random # ----- precomputed test vectors precomputed = {} # ----- Z = r'''/* WARNING: auto-generated (by autogen-test); do not edit */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "crypto_uint8.h" #include "crypto_uint32.h" #include "crypto_uint64.h" #include /* -lmceliece */ #include static const char *targeto = 0; static const char *targetp = 0; static const char *targeti = 0; static int ok = 1; #define fail ((ok = 0),printf) /* ----- rng and hash, from supercop/try-anything.c */ typedef crypto_uint8 u8; typedef crypto_uint32 u32; typedef crypto_uint64 u64; #define FOR(i,n) for (i = 0;i < n;++i) static u32 L32(u32 x,int c) { return (x << c) | ((x&0xffffffff) >> (32 - c)); } static u32 ld32(const u8 *x) { u32 u = x[3]; u = (u<<8)|x[2]; u = (u<<8)|x[1]; return (u<<8)|x[0]; } static void st32(u8 *x,u32 u) { int i; FOR(i,4) { x[i] = u; u >>= 8; } } static const u8 sigma[17] = "expand 32-byte k"; static void core_salsa(u8 *out,const u8 *in,const u8 *k) { u32 w[16],x[16],y[16],t[4]; int i,j,m; FOR(i,4) { x[5*i] = ld32(sigma+4*i); x[1+i] = ld32(k+4*i); x[6+i] = ld32(in+4*i); x[11+i] = ld32(k+16+4*i); } FOR(i,16) y[i] = x[i]; FOR(i,20) { FOR(j,4) { FOR(m,4) t[m] = x[(5*j+4*m)%16]; t[1] ^= L32(t[0]+t[3], 7); t[2] ^= L32(t[1]+t[0], 9); t[3] ^= L32(t[2]+t[1],13); t[0] ^= L32(t[3]+t[2],18); FOR(m,4) w[4*j+(j+m)%4] = t[m]; } FOR(m,16) x[m] = w[m]; } FOR(i,16) st32(out + 4 * i,x[i] + y[i]); } static void salsa20(u8 *c,u64 b,const u8 *n,const u8 *k) { u8 z[16],x[64]; u32 u,i; if (!b) return; FOR(i,16) z[i] = 0; FOR(i,8) z[i] = n[i]; while (b >= 64) { core_salsa(x,z,k); FOR(i,64) c[i] = x[i]; u = 1; for (i = 8;i < 16;++i) { u += (u32) z[i]; z[i] = u; u >>= 8; } b -= 64; c += 64; } if (b) { core_salsa(x,z,k); FOR(i,b) c[i] = x[i]; } } static void increment(u8 *n) { if (!++n[0]) if (!++n[1]) if (!++n[2]) if (!++n[3]) if (!++n[4]) if (!++n[5]) if (!++n[6]) if (!++n[7]) ; } static unsigned char testvector_n[8]; static void testvector_clear(void) { memset(testvector_n,0,sizeof testvector_n); } static void testvector(unsigned char *x,unsigned long long xlen) { const static unsigned char testvector_k[33] = "generate inputs for test vectors"; salsa20(x,xlen,testvector_n,testvector_k); increment(testvector_n); } static unsigned long long myrandom(void) { unsigned char x[8]; unsigned long long result; testvector(x,8); result = x[7]; result = (result<<8)|x[6]; result = (result<<8)|x[5]; result = (result<<8)|x[4]; result = (result<<8)|x[3]; result = (result<<8)|x[2]; result = (result<<8)|x[1]; result = (result<<8)|x[0]; return result; } static unsigned char canary_n[8]; static void canary(unsigned char *x,unsigned long long xlen) { const static unsigned char canary_k[33] = "generate pad to catch overwrites"; salsa20(x,xlen,canary_n,canary_k); increment(canary_n); } static void double_canary(unsigned char *x2,unsigned char *x,unsigned long long xlen) { canary(x - 16,16); canary(x + xlen,16); memcpy(x2 - 16,x - 16,16); memcpy(x2 + xlen,x + xlen,16); } static void input_prepare(unsigned char *x2,unsigned char *x,unsigned long long xlen) { testvector(x,xlen); canary(x - 16,16); canary(x + xlen,16); memcpy(x2 - 16,x - 16,xlen + 32); } static void input_compare(const unsigned char *x2,const unsigned char *x,unsigned long long xlen,const char *fun) { if (memcmp(x2 - 16,x - 16,xlen + 32)) { fail("failure: %s overwrites input\n",fun); } } static void output_prepare(unsigned char *x2,unsigned char *x,unsigned long long xlen) { canary(x - 16,xlen + 32); memcpy(x2 - 16,x - 16,xlen + 32); } static void output_compare(const unsigned char *x2,const unsigned char *x,unsigned long long xlen,const char *fun) { if (memcmp(x2 - 16,x - 16,16)) { fail("failure: %s writes before output\n",fun); } if (memcmp(x2 + xlen,x + xlen,16)) { fail("failure: %s writes after output\n",fun); } } /* ----- knownrandombytes */ static const int knownrandombytes_is_only_for_testing_not_for_cryptographic_use = 1; #define knownrandombytes randombytes #define QUARTERROUND(a,b,c,d) \ a += b; d = L32(d^a,16); \ c += d; b = L32(b^c,12); \ a += b; d = L32(d^a, 8); \ c += d; b = L32(b^c, 7); static void core_chacha(u8 *out,const u8 *in,const u8 *k) { u32 x[16],y[16]; int i,j; FOR(i,4) { x[i] = ld32(sigma+4*i); x[12+i] = ld32(in+4*i); } FOR(i,8) x[4+i] = ld32(k+4*i); FOR(i,16) y[i] = x[i]; FOR(i,10) { FOR(j,4) { QUARTERROUND(x[j],x[j+4],x[j+8],x[j+12]) } FOR(j,4) { QUARTERROUND(x[j],x[((j+1)&3)+4],x[((j+2)&3)+8],x[((j+3)&3)+12]) } } FOR(i,16) st32(out+4*i,x[i]+y[i]); } static void chacha20(u8 *c,u64 b,const u8 *n,const u8 *k) { u8 z[16],x[64]; u32 u,i; if (!b) return; FOR(i,16) z[i] = 0; FOR(i,8) z[i+8] = n[i]; while (b >= 64) { core_chacha(x,z,k); FOR(i,64) c[i] = x[i]; u = 1; FOR(i,8) { u += (u32) z[i]; z[i] = u; u >>= 8; } b -= 64; c += 64; } if (b) { core_chacha(x,z,k); FOR(i,b) c[i] = x[i]; } } #define crypto_rng_OUTPUTBYTES 736 static int crypto_rng( unsigned char *r, /* random output */ unsigned char *n, /* new key */ const unsigned char *g /* old key */ ) { static const unsigned char nonce[8] = {0}; unsigned char x[32+crypto_rng_OUTPUTBYTES]; chacha20(x,sizeof x,nonce,g); memcpy(n,x,32); memcpy(r,x+32,crypto_rng_OUTPUTBYTES); return 0; } static unsigned char knownrandombytes_g[32]; static unsigned char knownrandombytes_r[crypto_rng_OUTPUTBYTES]; static unsigned long long knownrandombytes_pos = crypto_rng_OUTPUTBYTES; static void knownrandombytes_clear(void) { memset(knownrandombytes_g,0,sizeof knownrandombytes_g); memset(knownrandombytes_r,0,sizeof knownrandombytes_r); knownrandombytes_pos = crypto_rng_OUTPUTBYTES; } void knownrandombytes(void *xvoid,long long xlen) { unsigned char *x = xvoid; assert(knownrandombytes_is_only_for_testing_not_for_cryptographic_use); while (xlen > 0) { if (knownrandombytes_pos == crypto_rng_OUTPUTBYTES) { crypto_rng(knownrandombytes_r,knownrandombytes_g,knownrandombytes_g); knownrandombytes_pos = 0; } *x++ = knownrandombytes_r[knownrandombytes_pos]; xlen -= 1; knownrandombytes_r[knownrandombytes_pos++] = 0; } } /* ----- checksums */ static unsigned char checksum_state[64]; static char checksum_hex[65]; static void checksum_expected(const char *expected) { long long i; for (i = 0;i < 32;++i) { checksum_hex[2 * i] = "0123456789abcdef"[15 & (checksum_state[i] >> 4)]; checksum_hex[2 * i + 1] = "0123456789abcdef"[15 & checksum_state[i]]; } checksum_hex[2 * i] = 0; if (strcmp(checksum_hex,expected)) fail("failure: checksum mismatch: %s expected %s\n",checksum_hex,expected); } static void checksum_clear(void) { memset(checksum_state,0,sizeof checksum_state); knownrandombytes_clear(); testvector_clear(); /* not necessary to clear canary */ } static void checksum(const unsigned char *x,unsigned long long xlen) { u8 block[16]; int i; while (xlen >= 16) { core_salsa(checksum_state,x,checksum_state); x += 16; xlen -= 16; } FOR(i,16) block[i] = 0; FOR(i,xlen) block[i] = x[i]; block[xlen] = 1; checksum_state[0] ^= 1; core_salsa(checksum_state,block,checksum_state); } #include "limits.inc" static void *callocplus(long long len) { long long i; unsigned char *x = calloc(1,len + 256); if (!x) abort(); for (i = 0;i < len + 256;++i) x[i] = random(); return x; } static void *aligned(void *x,long long len) { long long i; unsigned char *y = x; y += 64; y += 63 & (-(unsigned long) y); for (i = 0;i < len;++i) y[i] = 0; return y; } /* ----- catching SIGILL, SIGBUS, SIGSEGV, etc. */ static void forked(void (*test)(long long),long long impl) { fflush(stdout); pid_t child = fork(); int childstatus = -1; if (child == -1) { fprintf(stderr,"fatal: fork failed: %s",strerror(errno)); exit(111); } if (child == 0) { ok = 1; limits(); test(impl); if (!ok) exit(100); exit(0); } if (waitpid(child,&childstatus,0) != child) { fprintf(stderr,"fatal: wait failed: %s",strerror(errno)); exit(111); } if (childstatus) fail("failure: process failed, status %d\n",childstatus); fflush(stdout); } /* ----- endianness */ /* on big-endian machines, flip into little-endian */ /* other types of endianness are not supported */ static void endianness(unsigned char *e,unsigned long long words,unsigned long long bytesperword) { long long i = 1; if (1 == *(unsigned char *) &i) return; while (words > 0) { for (i = 0;2 * i < bytesperword;++i) { long long j = bytesperword - 1 - i; unsigned char ei = e[i]; e[i] = e[j]; e[j] = ei; } e += bytesperword; words -= 1; } } ''' checksums = {} operations = [] primitives = {} sizes = {} exports = {} prototypes = {} with open('api') as f: for line in f: line = line.strip() if line.startswith('crypto_'): line = line.split() x = line[0].split('/') assert len(x) == 2 o = x[0].split('_')[1] if o not in operations: operations += [o] p = x[1] if o not in primitives: primitives[o] = [] primitives[o] += [p] if len(line) > 1: checksums[o,p] = line[1],line[2] continue if line.startswith('#define '): x = line.split(' ') x = x[1].split('_') assert len(x) == 4 assert x[0] == 'crypto' o = x[1] p = x[2] if (o,p) not in sizes: sizes[o,p] = '' sizes[o,p] += line+'\n' continue if line.endswith(');'): fun,args = line[:-2].split('(') rettype,fun = fun.split() fun = fun.split('_') o = fun[1] assert fun[0] == 'crypto' if o not in exports: exports[o] = [] exports[o] += ['_'.join(fun[1:])] if o not in prototypes: prototypes[o] = [] prototypes[o] += [(rettype,fun,args)] todo = ( ('xof',( ('h',None,'4096'), ('m',None,'4096'), ),( ('loops','64','512'), ('maxtest','128','4096'), ),( ('',('h',),(),('hlen','m','mlen')), )), ('sort',( ('x',None,'4096'), ),( ('loops','1024','4096'), ('maxtest','128','4096'), ),( ('',(),('x',),('xwords',)), )), ('kem',( ('p','crypto_kem_PUBLICKEYBYTES','crypto_kem_PUBLICKEYBYTES'), ('s','crypto_kem_SECRETKEYBYTES','crypto_kem_SECRETKEYBYTES'), ('k','crypto_kem_BYTES','crypto_kem_BYTES'), ('c','crypto_kem_CIPHERTEXTBYTES','crypto_kem_CIPHERTEXTBYTES'), ('t','crypto_kem_BYTES','crypto_kem_BYTES'), ),( ('loops','8','64'), ),( ('_keypair',('p','s'),(),()), ('_enc',('c','k'),(),('p',)), ('_dec',('t',),(),('c','s')), )), ) for t in todo: o,vars,howmuch,tests = t Z += '\n' Z += '/* ----- %s, derived from supercop/crypto_%s/try.c */\n' % (o,o) for p in primitives[o]: Z += 'static const char *%s_%s_checksums[] = {\n' % (o,p) Z += ' "%s",\n' % checksums[o,p][0] Z += ' "%s",\n' % checksums[o,p][1] Z += '} ;\n' Z += '\n' for rettype,fun,args in prototypes[o]: Z += 'static %s (*%s)(%s);\n' % (rettype,'_'.join(fun),args) if (o,p) in sizes: for line in sizes[o,p].splitlines(): psize = line.split()[1] size1 = psize.replace('crypto_%s_%s_'%(o,p),'crypto_%s_'%o) size2 = psize.replace('crypto_','mceliece_') Z += '#define %s %s\n' % (size1,size2) Z += '\n' for v,initsize,allocsize in vars: Z += 'static void *storage_%s_%s_%s;\n' % (o,p,v) Z += 'static unsigned char *test_%s_%s_%s;\n' % (o,p,v) for v,initsize,allocsize in vars: Z += 'static void *storage_%s_%s_%s2;\n' % (o,p,v) Z += 'static unsigned char *test_%s_%s_%s2;\n' % (o,p,v) Z += '\n' if (o,p) in precomputed: Z += '#define precomputed_%s_%s_NUM %d\n' % (o,p,len(precomputed[o,p])) Z += '\n' for v,initsize,allocsize in vars: Z += 'static const unsigned char precomputed_%s_%s_%s[precomputed_%s_%s_NUM][%s] = {\n' % (o,p,v,o,p,allocsize) for precomp in precomputed[o,p]: Z += ' {%s},\n' % ','.join(str(c) for c in precomp[v]) Z += '} ;\n' Z += '\n' Z += 'static void test_%s_%s_impl(long long impl)\n' % (o,p) Z += '{\n' for v,initsize,allocsize in vars: Z += ' unsigned char *%s = test_%s_%s_%s;\n' % (v,o,p,v) for v,initsize,allocsize in vars: Z += ' unsigned char *%s2 = test_%s_%s_%s2;\n' % (v,o,p,v) for v,initsize,allocsize in vars: if initsize is None: Z += ' long long %slen;\n' % v if o == 'sort': Z += ' long long %swords;\n' % v else: Z += ' long long %slen = %s;\n' % (v,initsize) Z += '\n' Z += ' if (targeti && strcmp(targeti,mceliece_dispatch_%s_%s_implementation(impl))) return;\n' % (o,p) Z += ' if (impl >= 0) {\n' for rettype,fun,args in prototypes[o]: f2 = ['mceliece','dispatch',o,p]+fun[2:] Z += ' %s = %s(impl);\n' % ('_'.join(fun),'_'.join(f2)) Z += ' printf("%s_%s %%lld implementation %%s compiler %%s\\n",impl,mceliece_dispatch_%s_%s_implementation(impl),mceliece_dispatch_%s_%s_compiler(impl));\n' % (o,p,o,p,o,p) Z += ' } else {\n' for rettype,fun,args in prototypes[o]: f2 = ['mceliece',o,p]+fun[2:] Z += ' %s = %s;\n' % ('_'.join(fun),'_'.join(f2)) Z += ' printf("%s_%s selected implementation %%s compiler %%s\\n",mceliece_%s_%s_implementation(),mceliece_%s_%s_compiler());\n' % (o,p,o,p,o,p) Z += ' }\n' Z += ' for (long long checksumbig = 0;checksumbig < 2;++checksumbig) {\n' maxtestdefined = False for v,small,big in howmuch: Z += ' long long %s = checksumbig ? %s : %s;\n' % (v,big,small) if v == 'maxtest': maxtestdefined = True Z += '\n' Z += ' checksum_clear();\n' Z += '\n' Z += ' for (long long loop = 0;loop < loops;++loop) {\n' wantresult = False for f,output,inout,input in tests: cof = 'crypto_'+o+f for rettype,fun,args in prototypes[o]: if cof == '_'.join(fun): if rettype != 'void': wantresult = True if wantresult: Z += ' int result;\n' if maxtestdefined and 'mlen' in input: Z += ' mlen = myrandom() % (maxtest + 1);\n' if maxtestdefined and 'hlen' in input: Z += ' hlen = myrandom() % (maxtest + 1);\n' if maxtestdefined and 'xwords' in input: Z += ' xwords = myrandom() % (maxtest + 1);\n' Z += ' xlen = mceliece_sort_%s_BYTES*xwords;\n' % p Z += '\n' initialized = set() for f,output,inout,input in tests: cof = 'crypto_'+o+f cofrettype = None for rettype,fun,args in prototypes[o]: if cof == '_'.join(fun): cofrettype = rettype expected = '0' unexpected = 'nonzero' for v in output: if len(v) == 1: Z += ' output_prepare(%s2,%s,%slen);\n' % (v,v,v) # v now has CDE where C is canary, D is canary, E is canary # v2 now has same CDE # D is at start of v with specified length # C is 16 bytes before beginning # E is 16 bytes past end for v in input+inout: if len(v) == 1: if v in initialized: Z += ' memcpy(%s2,%s,%slen);\n' % (v,v,v) Z += ' double_canary(%s2,%s,%slen);\n' % (v,v,v) else: Z += ' input_prepare(%s2,%s,%slen);\n' % (v,v,v) # v now has CTE where C is canary, T is test data, E is canary # v2 has same CTE initialized.add(v) if o == 'sort': Z += ' endianness(x,xwords,mceliece_sort_%s_BYTES);\n' % p args = ','.join(output+inout+input) if cofrettype == 'void': Z += ' %s(%s);\n' % (cof,args) else: Z += ' result = %s(%s);\n' % (cof,args) Z += ' if (result != %s) fail("failure: %s returns %s\\n");\n' % (expected,cof,unexpected) if o == 'sort': Z += ' endianness(x,xwords,mceliece_sort_%s_BYTES);\n' % p if cof == 'crypto_kem_dec': Z += ' if (memcmp(t,k,klen) != 0) fail("failure: %s does not match k\\n");\n' % cof for v in output+inout: if len(v) == 1: Z += ' checksum(%s,%slen);\n' % (v,v) # output v,v2 now has COE,CDE where O is output; checksum O initialized.add(v) for v in output+inout: if len(v) == 1: if cof == 'crypto_sign_open' and v == 't': Z += ' output_compare(%s2,%s,%slen,"%s");\n' % (v,v,'c',cof) else: Z += ' output_compare(%s2,%s,%slen,"%s");\n' % (v,v,v,cof) # output_compare checks COE,CDE for equal C, equal E for v in input: if len(v) == 1: Z += ' input_compare(%s2,%s,%slen,"%s");\n' % (v,v,v,cof) # input_compare checks CTE,CTE for equal C, equal T, equal E deterministic = True if inout+input == (): deterministic = False if cof == 'crypto_kem_enc': deterministic = False if deterministic: Z += '\n' for v in output+inout+input: if len(v) == 1: Z += ' double_canary(%s2,%s,%slen);\n' % (v,v,v) # old output v,v2: COE,CDE; new v,v2: FOG,FDG where F,G are new canaries # old inout v,v2: COE,CTE; new v,v2: FOG,FTG # old input v,v2: CTE,CTE; new v,v2: FTG,FTG if o == 'sort': Z += ' endianness(x2,xwords,mceliece_sort_%s_BYTES);\n' % p args = ','.join([v if v.endswith('words') or v.endswith('len') else v+'2' for v in output+inout+input]) if cofrettype == 'void': Z += ' %s(%s);\n' % (cof,args) else: Z += ' result = %s(%s);\n' % (cof,args) Z += ' if (result != %s) fail("failure: %s returns %s\\n");\n' % (expected,cof,unexpected) if o == 'sort': Z += ' endianness(x2,xwords,mceliece_sort_%s_BYTES);\n' % p for w in output + inout: if len(w) == 1: # w,w2: COE,COE; goal now is to compare O Z += ' if (memcmp(%s2,%s,%slen) != 0) fail("failure: %s is nondeterministic\\n");\n' % (w,w,w,cof) overlap = deterministic if inout != (): overlap = False if overlap: for y in output: if len(y) == 1: Z += '\n' for v in output: if len(v) == 1: Z += ' double_canary(%s2,%s,%slen);\n' % (v,v,v) for v in input: if len(v) == 1: Z += ' double_canary(%s2,%s,%slen);\n' % (v,v,v) for x in input: if len(x) == 1: # try writing to x2 instead of y, while reading x2 args = ','.join([x+'2' if v==y else v for v in output] + [x+'2' if v==x else v for v in input]) if cofrettype == 'void': Z += ' %s(%s);\n' % (cof,args) else: Z += ' result = %s(%s);\n' % (cof,args) Z += ' if (result != %s) fail("failure: %s with %s=%s overlap returns %s\\n");\n' % (expected,cof,x,y,unexpected) Z += ' if (memcmp(%s2,%s,%slen) != 0) fail("failure: %s does not handle %s=%s overlap\\n");\n' % (x,y,y,cof,x,y) Z += ' memcpy(%s2,%s,%slen);\n' % (x,x,x) if cof == 'crypto_kem_dec': Z += '\n' for tweaks in range(3): Z += ' c[myrandom() % clen] += 1 + (myrandom() % 255);\n' Z += ' if (%s(t,c,s) == 0)\n' % cof Z += ' checksum(t,tlen);\n' Z += ' else\n' Z += ' checksum(c,clen);\n' Z += ' }\n' Z += ' checksum_expected(%s_%s_checksums[checksumbig]);\n' % (o,p) Z += ' }\n' # ----- test vectors computed by python for f,output,inout,input in tests: cof = 'crypto_'+o+f if (o,p) in precomputed: Z += ' for (long long precomp = 0;precomp < precomputed_%s_%s_NUM;++precomp) {\n' % (o,p) for v,initsize,allocsize in vars: if v in output: Z += ' output_prepare(%s2,%s,%s);\n' % (v,v,allocsize) if v in input+inout: Z += ' input_prepare(%s2,%s,%s);\n' % (v,v,allocsize) Z += ' memcpy(%s,precomputed_%s_%s_%s[precomp],%s);\n' % (v,o,p,v,allocsize) Z += ' memcpy(%s2,precomputed_%s_%s_%s[precomp],%s);\n' % (v,o,p,v,allocsize) args = ','.join(output+inout+input) Z += ' %s(%s);\n' % (cof,args) for v,initsize,allocsize in vars: if v in output+inout: Z += ' if (memcmp(%s,precomputed_%s_%s_%s[precomp],%s)) {\n' % (v,o,p,v,allocsize) Z += ' fail("failure: %s fails precomputed test vectors\\n");\n' % cof Z += ' printf("expected %s: ");\n' % v Z += ' for (long long pos = 0;pos < %s;++pos) printf("%%02x",precomputed_%s_%s_%s[precomp][pos]);\n' % (allocsize,o,p,v) Z += ' printf("\\n");\n' Z += ' printf("received %s: ");\n' % v Z += ' for (long long pos = 0;pos < %s;++pos) printf("%%02x",%s[pos]);\n' % (allocsize,v) Z += ' printf("\\n");\n' Z += ' }\n' for v,initsize,allocsize in vars: if v in output+inout: Z += ' output_compare(%s2,%s,%s,"%s");\n' % (v,v,allocsize,cof) if v in input: Z += ' input_compare(%s2,%s,%s,"%s");\n' % (v,v,allocsize,cof) Z += ' }\n' Z += '}\n' Z += '\n' Z += 'static void test_%s_%s(void)\n' % (o,p) Z += '{\n' Z += ' if (targeto && strcmp(targeto,"%s")) return;\n' % o Z += ' if (targetp && strcmp(targetp,"%s")) return;\n' % p if cof == 'crypto_sort': for v,initsize,allocsize in vars: Z += ' storage_%s_%s_%s = callocplus(mceliece_sort_%s_BYTES*%s);\n' % (o,p,v,p,allocsize) Z += ' test_%s_%s_%s = aligned(storage_%s_%s_%s,mceliece_sort_%s_BYTES*%s);\n' % (o,p,v,o,p,v,p,allocsize) for v,initsize,allocsize in vars: Z += ' storage_%s_%s_%s2 = callocplus(mceliece_sort_%s_BYTES*%s);\n' % (o,p,v,p,allocsize) Z += ' test_%s_%s_%s2 = aligned(storage_%s_%s_%s2,mceliece_sort_%s_BYTES*%s);\n' % (o,p,v,o,p,v,p,allocsize) else: for v,initsize,allocsize in vars: Z += ' storage_%s_%s_%s = callocplus(%s);\n' % (o,p,v,allocsize) Z += ' test_%s_%s_%s = aligned(storage_%s_%s_%s,%s);\n' % (o,p,v,o,p,v,allocsize) for v,initsize,allocsize in vars: Z += ' storage_%s_%s_%s2 = callocplus(%s);\n' % (o,p,v,allocsize) Z += ' test_%s_%s_%s2 = aligned(storage_%s_%s_%s2,%s);\n' % (o,p,v,o,p,v,allocsize) Z += '\n' Z += ' for (long long offset = 0;offset < 2;++offset) {\n' Z += ' printf("%s_%s offset %%lld\\n",offset);\n' % (o,p) Z += ' for (long long impl = -1;impl < mceliece_numimpl_%s_%s();++impl)\n' % (o,p) Z += ' forked(test_%s_%s_impl,impl);\n' % (o,p) for v,initsize,allocsize in vars: Z += ' ++test_%s_%s_%s;\n' % (o,p,v) for v,initsize,allocsize in vars: Z += ' ++test_%s_%s_%s2;\n' % (o,p,v) Z += ' }\n' for v,initsize,allocsize in reversed(vars): Z += ' free(storage_%s_%s_%s2);\n' % (o,p,v) for v,initsize,allocsize in reversed(vars): Z += ' free(storage_%s_%s_%s);\n' % (o,p,v) Z += '}\n' if (o,p) in sizes: for line in sizes[o,p].splitlines(): psize = line.split()[1] size1 = psize.replace('crypto_%s_%s_'%(o,p),'crypto_%s_'%o) Z += '#undef %s\n' % size1 Z += '\n' Z += r'''/* ----- top level */ #include "print_cpuid.inc" int main(int argc,char **argv) { setvbuf(stdout,0,_IOLBF,0); printf("mceliece version %s\n",mceliece_version); printf("mceliece arch %s\n",mceliece_arch); print_cpuid(); if (*argv) ++argv; if (*argv) { targeto = *argv++; if (*argv) { targetp = *argv++; if (*argv) { targeti = *argv++; } } } ''' for t in todo: o,vars,howmuch,tests = t for p in primitives[o]: Z += ' test_%s_%s();\n' % (o,p) Z += r''' if (!ok) { printf("some tests failed\n"); return 100; } printf("all tests succeeded\n"); return 0; } ''' with open('command/mceliece-test.c','w') as f: f.write(Z) libmceliece-20230612/benchmarks/0000755000000000000000000000000014441554466015040 5ustar rootrootlibmceliece-20230612/benchmarks/pi4b0000644000000000000000000020113114441554466015617 0ustar rootrootmceliece version 20230219 mceliece arch arm64 cpuid 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 cpucycles selected persecond 1500000000 cpucycles selected implementation arm64-pmc cpucycles selected 0 9 +13+13+0+0+0+0+0+0+0+0+0+0+0+0+0 randombytes selected 0 25 +561+22+14+1+0+0+0+0+0+0+0+0+0+0+0 randombytes selected 1 6796 +3684+452+37+25-8-32+32-48-33-8+0-16+2-30+14 randombytes selected 2 6771 +875+168-6-22-15-48+6+12+0+12+0+12+0+12+0 randombytes selected 4 6791 +855+4+0+51-52-42-10-52+13-47+13-47+13-47+13 randombytes selected 7 6818 +938+32+0+7-60-16-47+6-47+6-47+6-47+6-45 randombytes selected 11 6831 +800+73+60-2+16+0+32-11+20+29-99-8-52+0-60 randombytes selected 17 6775 +858+34+72-5+1-21-14-7+26-16+13-19-5+0+16 randombytes selected 26 6836 +804+116+79-13+8+134+10+28-42+0-105-67-61-54-39 randombytes selected 40 7326 +964+85+37-24-3+19-11-5+0-5+0-5+0-5+0 randombytes selected 61 7363 +821+171+102+16+37+0-1+16-14-34-3-32+9-17-37 randombytes selected 92 10371 +925+118+46+32-11-22+0-22+0-22+0-22+0-22+0 randombytes selected 139 13312 +898+114+53-21+9-76-46-18+0+14141+505+45-25-42-41 randombytes selected 209 16263 +1049+139-101+0-6+12-36-35+17-29+24-35+17-29+24 randombytes selected 314 19127 +843+130+23-40+45-18-13-31-39-17+60+0+3+59-15 randombytes selected 472 27973 +749-93+2-15-24+6+0+6+0+5+0+5+0+5-62 randombytes selected 709 39438 +875+31+9-16+129-80+52+19-2-30-17+0-26-52+7 randombytes selected 1064 53984 +867+285-1+155-1+18-33+206+19-32+0-31-28-10+248 randombytes selected 1597 77277 +1084+64-16+156-21-13+48+386-20-30+33-42+0-41+0 randombytes selected 2396 115618 +255+71-428+0-568+50+45-586+69-577-307-599+40-586+42 randombytes selected 3595 170387 +13118+668+826-41-59-99+752-70+805+830+0-99+909-164-10 randombytes selected 5393 251923 +1296+33-23-1+0+51+41-35+45-33-23-8-131+51171+458 randombytes selected 8090 373929 +812+67+498+104+0+56-48-7-19-13-3-10-29+12039+145 randombytes selected 12136 557163 +1155-44+0-27+1075-151-70-169-159+10807+252+24+24+752-123 randombytes selected 18205 834100 +108+386+43799-514+0-782-789-926-956+10664+7147+7041+8704-864-904 randombytes selected 27308 1246251 +11661-12-174-219-240+41805+250+0-240-183+20664+12400+872-171+8217 randombytes selected 40963 1870177 +1112-1871+43789+526-2058+16856-2688-1527+7235+20588-2837-1772+39108+0-1874 randombytes selected 61445 2799934 +0+9051-1251+40197-1148+9058-2513-1235+7189-400+40816-1194+30061-1379+7682 sort_int32 selected implementation portable4 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 selected 0 44 +784+1+2+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 selected 1 44 +12+3+0+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 selected 2 68 +1154+55+25+5+0+0+0+0+0+0+0+0+0+0+0 sort_int32 selected 4 159 +1251+113+123+82+0+0+0+0+0+0+0+0+0+0+0 sort_int32 selected 7 334 +440+267+228+120+47+149+53+0-12-21-21-21-21-21-21 sort_int32 selected 11 556 +699+524+263+10-3+0+0+0+0+0+0+0+0+0+0 sort_int32 selected 17 853 +1075+960+771+253+113+2+0+0+0+0+0+0+0+0+0 sort_int32 selected 26 1541 +1267+1156+927+407+124+48+23+0-2+0-3+0-2+0-3 sort_int32 selected 40 2637 +1559+1199+841+293+159+57+52+0-13-30-30-30-30-30-30 sort_int32 selected 61 4294 +1388+1075+604+371+176+98+4-1+0+0+0+0+0+0+0 sort_int32 selected 92 7843 +1423+1421+956+273+59+66+22+0-21-21-21-21-21-21-21 sort_int32 selected 139 13495 +2757+2220+1486+765+417+258+29+0-109-133-202-191-215-210-220 sort_int32 selected 209 22971 +2485+1704+968+469+380+166+27+0-16-46-28-46-28-44-28 sort_int32 selected 314 38917 +2685+1840+941+314+180+69+10+0-9-36-38-38-26-38-38 sort_int32 selected 472 63868 +1469+968+494+273+106+26+20-30-31-35-33-38+0-30-38 sort_int32 selected 709 109380 +3798+1932+667+314+36+10-129-232-251+19671+0-156-222-184-201 sort_int32 selected 1064 178716 +2417+1284+599+193+67+58+20-60-44-52-4-56+0-56+0 sort_int32 selected 1597 299955 +1681+772+1597+281-115-140+12007+2+2-19-15+0-30-3-30 sort_int32 selected 2396 497217 +1871+810+231+390+209+46547+381-79+0-96-24-18-29-21-15 sort_int32 selected 3595 809521 +2245+1148-217+0+1817-360+1622+8929-452-513+1675-464-548-465+42446 sort_int32 selected 5393 1348567 +2190+1632+13400+207+575-20+0+8772-140-207-99+41673-488-358-405 sort_int32 selected 8090 2186294 +2753+351+9815-214+40600-659-642+18841-962-685+8277-549-517+40121+0 sort_int32 selected 12136 3678776 +3248-8437+31452-9473-120+7273-963+31973-9363+0+6914-10513+27317+8153-9870 sort_int32 0 implementation portable4 compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. sort_int32 0 0 43 +334+15+15+1+0+0+0+0+0+0+0+0+0+0+0 sort_int32 0 1 43 +30+3+0+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 0 2 62 +298+18+1+2+0+0+0+0+0+0+0+0+0+0+0 sort_int32 0 4 115 +572+73+92+56+20+0+0+0+0+0+0+0+0+0+0 sort_int32 0 7 254 +543+352+204+145+108+14+22+0-2-2-2-2-2-2-2 sort_int32 0 11 490 +669+662+407+340+256+51+0+0+0+0+0+0+0+0+0 sort_int32 0 17 826 +1161+978+884+637+436+99+29+0-33-53-53-53-53-53-53 sort_int32 0 26 1422 +1521+1316+856+642+364+169-13-16+1-16-16+0-16-16+0 sort_int32 0 40 2597 +1682+1250+832+432+234+143+41+0-14-17-17-17-17-17-17 sort_int32 0 61 4553 +1931+1279+943+354+159+99+36+0-39-58-75-75-75-75-70 sort_int32 0 92 8307 +1751+1393+907+737+369+155+63+0-4-29-29-44-14-14-59 sort_int32 0 139 14545 +2495+1732+1101+622+420+199+13+0-113-223-215-259-245-259-245 sort_int32 0 209 24899 +2311+1860+968+459+179+16-78-147-134-110+53436-129+0-169-124 sort_int32 0 314 42527 +2289+1813+1089+442+338+129+38-30+0-96-124-98-104-138-119 sort_int32 0 472 70192 +1289+855+547+244+116+74+0-34-12-3+48-10-29-27-23 sort_int32 0 709 120283 +3380+2252+1423+686+385+112+52+0-103-57-114-128-1-83-58 sort_int32 0 1064 198872 +1427+983+300+168+119+0+29+11527-41-167-131-215-141-248-164 sort_int32 0 1597 334352 +770+391-47+142+42-246-133-137-47+10+23+10557-65-146+0 sort_int32 0 2396 556145 +1023+524+150+40-16-148+135+44092-86-111-207-120-194+3+0 sort_int32 0 3595 911103 +13467+934-786+190-885+25+97+6939-1210-546-94+0-1234+40995-627 sort_int32 0 5393 1516743 +4403+15033+1872-644-130+8468-374-500+60+41174-123-495-406+9907+0 sort_int32 0 8090 2473570 +10797+1475+33916-8176-8342+462-8462+0-8287-8996+32324-9448+1627-8886+83 sort_int32 0 12136 4145499 +35837+634-8316-74+28832-7575+0-669+40042-9181+260+4523-9400+30118-1126 sort_int32 1 implementation portable4 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 1 0 44 +46+14+1+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 1 1 44 +10+0+3+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 1 2 68 +254+116+64+10+3+0+0+0+0+0+0+0+0+0+0 sort_int32 1 4 159 +308+119+102+10+0+0+0+0+0+0+0+0+0+0+0 sort_int32 1 7 313 +563+267+101+8+0+0+0+0+0+0+0+0+0+0+0 sort_int32 1 11 556 +527+321+203+30+8+0+0+0+0+0+0+0+0+0+0 sort_int32 1 17 853 +1050+625+376+200+117+24+2+0+0+0+0+0+0+0+0 sort_int32 1 26 1484 +1115+734+326+136+57+19-2+0-3+0-2+0-3+0-2 sort_int32 1 40 2608 +1187+741+475+197+144+126+50+0-26-26-26-26-26-26-26 sort_int32 1 61 4321 +1423+808+504+169+76+0+0+6+0+0-27-27-27-27-27 sort_int32 1 92 7801 +1390+706+454+167+157+38+20+0+0+0+0+0+0+0+0 sort_int32 1 139 13260 +2400+1650+959+495+159+92+36-16+0-16+0-16+0-16+0 sort_int32 1 209 22893 +2061+1334+815+393+163+70-2+0-2+0+14-13-16-50-31 sort_int32 1 314 38847 +2175+1461+812+254+132+17+13-31-24+0-8-42-18-20-42 sort_int32 1 472 63846 +1307+930+325+105+87+57-3+0-47+2-52-10-39-22-52 sort_int32 1 709 109058 +3259+89525+1157+528+238+48+14-35-57-33-37+0-32-36-47 sort_int32 1 1064 178754 +2244+1415+579+416+316+179+0+0-132-119-188-147-126-162-158 sort_int32 1 1597 299850 +1319+473+296+11757-94+55+0+11+47-77-51-82-66-82-66 sort_int32 1 2396 497222 +2147+868+286+11213+125+84+40+0-113-59-73-164-86-150-145 sort_int32 1 3595 808947 +1817+375+63-155-251-347+12366+78-101+0-3-2+29+8282-63 sort_int32 1 5393 1348590 +1076+169+46457+599-123+312+10476-88+0-108-197+8251-221-625-321 sort_int32 1 8090 2186950 +1324+11661+369-42+7761-1453-300+41798-438+9885+0-507+8284-866-566 sort_int32 1 12136 3678222 +4412-8084-717+32074-8921+1225-9255+41+89296-9672+7645-9014+0+31452-9602 xof_shake256 selected implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 selected 0 2149 +10003+107+71+44+44+28+2+0+0+0+0+0+0+0+0 xof_shake256 selected 1 2151 +326+20+17+31+16+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 2 2151 +190+32+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 4 2149 +203+18+16+16+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 7 2149 +227+2+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 11 2148 +190+19+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 17 2148 +211+34+0+0+0+1+0+0+0+0+0+0+0+6+0 xof_shake256 selected 26 2148 +187+17+16+0+1+1+0+0+0+0+0+0+0+0+1 xof_shake256 selected 40 2151 +189+76+31+19+19+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 61 2151 +213+16+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 92 2155 +269+48+34+0+0+4+0+0+0+0+0+0+0+0+0 xof_shake256 selected 139 3926 +316+52+19+35+19+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 209 3931 +315+36+16+1+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 314 5685 +326+69+20+35+17+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 472 7413 +216+42+1+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 709 10897 +248+34+0+0+0+0+0+0+0+0+0+0+0+0+1 xof_shake256 selected 1064 14426 +251+45+14+1+0+0+0+0-1+0+0+0+0+0+0 xof_shake256 selected 1597 21368 +225+2+2+0+0+0+0+0+0+0+0+0+0+3+0 xof_shake256 selected 2396 31818 +311+40+19+0+33+2+0+3+0+0+0+3+0+0+0 xof_shake256 selected 3595 47502 +49240+110+0+15+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected 5393 70165 +303+21+0+0+0+3+0+0+1+0+3+0+0+0+3 xof_shake256 selected 8090 105057 +296+23-1+2+0+0+5+0+0+0+0+2+0+3+2 xof_shake256 selected 12136 157480 +281+75-1-1-1+0-1+11457+94+0-1+2-1-1+3 xof_shake256 selected 18205 234269 +349+45+9+10+10-4-3-2+1+0-2-1-1+7-4 xof_shake256 selected 27308 351320 +338-18+34+9-1-1+0+0+0+3-2-2+1+44935+37 xof_shake256 selected 40963 527408 +358+112-111-109+79+11743-137-2-2+5-5+1+0+5-3 xof_shake256 selected 61445 788922 +369+23-7+0+41302+55-7+6-8-7-6-4+9832+5-5 xof_shake256 selected -1 1994 +164+29+13+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -2 1999 +119+47+34+0+0+0+0+0+1+0+0+0+0+0+0 xof_shake256 selected -4 2011 +122+52+34+0+0+0+0+0+0+1+0+0+0+0+0 xof_shake256 selected -7 2028 +123+53+31+16+0+0+1+0+0+2+0+0+0+0+0 xof_shake256 selected -11 2052 +123+48+37+20+20+0+0+0+0+1+0+0+0+0+1 xof_shake256 selected -17 2088 +136+53+2+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -26 2147 +159+36+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -40 2252 +137+35+5+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -61 2379 +122+0+3+0+0+0+0+0+0+0+0+0+0+0+1 xof_shake256 selected -92 2572 +134+0+3+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -139 4114 +165+36+16+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -209 4567 +103+17+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -314 6480 +207+19+0+0+0+15+0+0+0+0+0+0+0+0+0 xof_shake256 selected -472 8710 +139+2+3+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -709 12658 +177+20+0+0+0+0+0+0+0+0+0+0+1+0+0 xof_shake256 selected -1064 17376 +171+23+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -1597 25675 +153+2+3+3+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 selected -2396 38122 +148+2+3+3+0+0+0+0+0+0+0+0+0+1+0 xof_shake256 selected -3595 56803 +276-6-4-4-1+39+0+0+0+0+0+0+0+4+0 xof_shake256 selected -5393 84184 +180-3-1-1-1+38+0+0+0+0+0+0+0+0+0 xof_shake256 selected -8090 125885 +168-5-4-4+0+0-3+0-3+0+0-3+0+0-3 xof_shake256 selected -12136 188407 +183+43852+36-4-4-2-4+0+0+3+0+3+0+0+6 xof_shake256 selected -18205 281008 +262+15-11-11-8+32+35-3+11264+4-7+3+0+0-3 xof_shake256 selected -27308 421179 +207-7+0+1+1+1+10708-35-34-3-31-31-31+1+1 xof_shake256 selected -40963 631936 +480+42+8+10+4-3+0+0+0+10383+23-2-8+0+0 xof_shake256 selected -61445 946251 +519+41-1-9-3+42190+51-2+0-13-12+9750+20+5-7 xof_shake256 0 implementation tweet compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 0 0 21974 +3766+1019+854+411+150+96+30-1-1-1-1+0-1-1-1 xof_shake256 0 1 21962 +454+47+45+45+59+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 2 21962 +413+1+0+0+0+0+0+0+2+0+0+0+0+0+0 xof_shake256 0 4 21959 +318+40+40+20+20+22+0+0+0+0+0+0+0+0+0 xof_shake256 0 7 21959 +332+0+43426+221+20+0+0+0+0+1+0+0+0+0+0 xof_shake256 0 11 21958 +349+38+20+20+20+20+0+0+0+0+0+0+1+0+0 xof_shake256 0 17 21959 +369+39+19+0+0+0+0+0+0+0+1+0+0+0+0 xof_shake256 0 26 21965 +347+25+0+0+0+0+0+0+1+0+0+0+0+0+0 xof_shake256 0 40 21967 +283+22+21+0+0+0+2+0+0+0+0+0+0+0+0 xof_shake256 0 61 21967 +328+20+19+0+2+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 92 21971 +407+20+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 139 43230 +511+74+38+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 209 43233 +377+41+0+0+0+0+0+0+0+0+1+0+0+0+0 xof_shake256 0 314 64514 +353+67+17+0+0+1+0+0+0+0+0+0+1+0+0 xof_shake256 0 472 85780 +293+18+0+0+0+0+0+0+11226+31+0+0+2+0+0 xof_shake256 0 709 128311 +384+50+2+0+0+0+0+0+1+1+0+0+0+0+0 xof_shake256 0 1064 170854 +339+66+22+22+0+0+0+0+0+2+0+0+1+0+0 xof_shake256 0 1597 255924 +311+10506+28+0-1+0-1-1-1+0+0-1-1-1+0 xof_shake256 0 2396 383520 +420+21+1+0+0+53476+47+1+0+0+1+0+0+0+0 xof_shake256 0 3595 574923 +409+22+11280+145-1-1+0-1-1+2-1+0-1+8803+26 xof_shake256 0 5393 850663 +1200+756+733+733+44253+0-148-147-145-148-147+9140+57-143-141 xof_shake256 0 8090 1277738 -1812+8406-2162-2276-2278-2280+39404+81+0-3+9338+236+0+4+1 xof_shake256 0 12136 1914570 +2324+1896+44532-31-108+9396+41-108+8462-5-103+38123+0-107-104 xof_shake256 0 18205 2850238 +0+10492-277+37949-2426+45037-2420+6977-2426+35339-2423+6813-2275+4922-2280 xof_shake256 0 27308 4283898 -12001+2118-1456-2513-8889+96+7603-7623+33693+1923+0-7603+29596+1518-7636 xof_shake256 0 40963 6433927 -825-3455+26383-1962-3789+36536-1556+0+31188+7717+4151+27186-2170+33458-2077 xof_shake256 0 61445 9653078 +29222-20848+10552+74049-27816+9458-27932+7939-19987+0-19784+60-18810+3718-34416 xof_shake256 0 -1 21973 +359+67+35+0+0+8+0+0+0+0+0+0+0+0+0 xof_shake256 0 -2 21972 +259+32+35+0+0+5+0+0+0+0+0+0+0+0+0 xof_shake256 0 -4 21970 +308+36+36+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 -7 21967 +279+39+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 -11 21963 +327+43+57+25+25+0+0+0+5+0+0+0+0+0+0 xof_shake256 0 -17 21957 +324+47+30+0+0+0+0+0+0+0+0+0+0+8+0 xof_shake256 0 -26 21980 +300+52+0+0+0+0+0+5+0+0+0+0+0+0+0 xof_shake256 0 -40 21972 +289+0+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 -61 21962 +287+0+0+0+0+0+0+0+0+0+0+1+0+10550+75 xof_shake256 0 -92 21947 +335+0+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 0 -139 43268 +337+49+15+0+0+0+0+1+0+0+0+0+0+0+0 xof_shake256 0 -209 43235 +311+0+0+0+0+0+0+0+0+0+0+0+0+1+1 xof_shake256 0 -314 64526 +282+0+0+0+0+0+0+0+0+1+0+0+0+1+1 xof_shake256 0 -472 85792 +293+9-5+0+0+0+0+1+0+0+0+0+0+0+0 xof_shake256 0 -709 128361 +337+8-6+0-1+1-1+0+1-1-1+51867+71-1+0 xof_shake256 0 -1064 170872 +324+11-4+0+2+1+0+1+0+0+0+1+0+0+0 xof_shake256 0 -1597 255981 +319+11-4-1+1+1-1+1+0+11500+62-1-1-3+0 xof_shake256 0 -2396 383645 +369-1+1-1-1+0+1+0-1+0+10353+57-1-1+1 xof_shake256 0 -3595 575149 +343+1-4+0+2+0+43057+37-7-6-8+0+2+1+0 xof_shake256 0 -5393 851726 +11613+61+10-16-2+2-2+7302+50+0-1-2-1-3+39122 xof_shake256 0 -8090 1277275 +362+0-15+11019+53-3-8+7478+53-11-11-11+39264+81-6 xof_shake256 0 -12136 1915632 +11427+0-72+7130+3-63+39528+12-66+9269-8-67-68+7383-11 xof_shake256 0 -18205 2858890 +253+9785-57-114+7493-107+52486+0+3025-8362-770-8426+29079-8383+831 xof_shake256 0 -27308 4294081 +4782+27006-4163-13608+4485+29028-9167+25-1462+27932-9173+0-809-6957+29975 xof_shake256 0 -40963 6460829 +0+29433-1299+34075-7940-9302+20018-7026-9436+21486-8034-1869+32763+4811+3426 xof_shake256 0 -61445 9673270 +26104-36455-1349-37199+0-27788+15445+4344+19493-4677+26458-9437+24995+21871-60455 xof_shake256 1 implementation tweet compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 1 0 11760 +4988+1598+1326+887+584+332+156+0-68-150-205-206-206-206-206 xof_shake256 1 1 11534 +326+51+40+40+0+0+0+0+0+2+0+2+0+0+0 xof_shake256 1 2 11547 +240+18-1+0-1+0-1+0-1-1+1-1+4-1+0 xof_shake256 1 4 11537 +235+42+15+3+0+0+0+0+1+0+0+0+0+0+0 xof_shake256 1 7 11540 +211+46+21+1+0+3+0+0+0+0+0+0+5+0+0 xof_shake256 1 11 11540 +302+42+21+0+0+2+0+0+0+0+0+0+0+0+0 xof_shake256 1 17 11538 +227+16+0+1+0+3+0+0+0+0+0+0+0+1+0 xof_shake256 1 26 11545 +211+26+0+0+2+0+0+0+0+0+0-1+0+5+0 xof_shake256 1 40 11523 +233+51+18+0+0+0+0+0+1+1+0+0+1+0+0 xof_shake256 1 61 11539 +282+97+36+83+0+0+0+1+0+0+0+0+0+0+0 xof_shake256 1 92 11566 +200+42+41+10+22-6+2+0+4+0+0+0+0+0+0 xof_shake256 1 139 22208 +262+40+27+11-1+2+0-1-1+1+0+0-1+2+0 xof_shake256 1 209 22244 +267+45-1-1-1-1-1+1+0+0-1-1+1+0+3 xof_shake256 1 314 32943 +274+53+0-1+0+0+0+4+2+0+0+0+3+1+1 xof_shake256 1 472 43630 +261+49+14-1+0+1-2-1+0-1+0+1-3+0-2 xof_shake256 1 709 65000 +409+44+94+34+0+0-1+1+0+1-1+0-1-1+3 xof_shake256 1 1064 86407 +289+39+39+8+11-3-7-5-5-2+0-4+0-3+2 xof_shake256 1 1597 129148 +285+33-2+0+2+5+1-1-2-3-2+0-1+3+2 xof_shake256 1 2396 193624 -41-269-302-289-296+43780+68+0+0-3+4+4+4+3+0 xof_shake256 1 3595 289937 +358+34+2-3-1+0-3+1-9+0+1-4-2+11255+27 xof_shake256 1 5393 429824 +1370+10+1+0+0+0+0+0+0+0+0+10138-635-688-687 xof_shake256 1 8090 641378 +1294+974+973+980+979+43233+0-108-107-107-101-100-96-100+17799 xof_shake256 1 12136 964621 -2812-3065-3085-3085+8246+123+9+10+9+10+0+38874-1835-1858-1877 xof_shake256 1 18205 1430632 +11975+63-10+0+7636+79-3-20+39582-6-20-14+9475+215-12 xof_shake256 1 27308 2152516 +4318-6482+35354-112+0+9342+81-18+5704-3179-3254+33462-4311+5159-4288 xof_shake256 1 40963 3231594 -3306+36460-4419+5075-4477+3467-4389+30134-9745+0-9147+5338+30472-4464+4929 xof_shake256 1 61445 4830821 -941+31952+216-1295+28769-33-9333-1314+28397+127+5912-9330+30470+0-1356 xof_shake256 1 -1 11476 +216+73+26+0+1+0+0+2+0+0+0+0+0+0+0 xof_shake256 1 -2 11477 +244+34+12+0+1-2+2+4+0+1+0+0+0+0+0 xof_shake256 1 -4 11476 +151+50+39-1+0+0+0+0+1+0+0+0+0+4+0 xof_shake256 1 -7 11484 +199+77-4+0+0+0+0+2+1+0+1+0+0+0+0 xof_shake256 1 -11 11484 +258+87+27+24+22+23+44-2-1-1-2+0-2+0-2 xof_shake256 1 -17 11531 +160+26+12-22+0-22+0-22+0-22+0-22+0-22+0 xof_shake256 1 -26 11518 +172+15+0+0+1+1+1+1+0+0+0+0-1+0+0 xof_shake256 1 -40 11526 +137+4+0+0+0+1+1+0+0+0+0+0+0+0+0 xof_shake256 1 -61 11531 +139+10+1+0+0+0+0+0+0+0+0-1+1+0+2 xof_shake256 1 -92 11552 +152+20+0+1+0+0-1+0+0+1+0+0+0+0+2 xof_shake256 1 -139 22822 +120+39-33+0+0+1+0+0+0+9+6-2+4+0+0 xof_shake256 1 -209 22827 +141+10+0+5+0+0-1+0+0+0+0+0+0+1+0 xof_shake256 1 -314 34090 +118+16+5+2-2+0+0+0+3+0+1+0+0+0+0 xof_shake256 1 -472 45371 +124+2+0-2-2-1+0-1+6+1+2+0-1+0-1 xof_shake256 1 -709 67888 +129+9-1+2-1+2-2+0+0-5-2-3+2-1+12 xof_shake256 1 -1064 90476 +197+18+0+0-1+5+0-1-1-1-3+0+1+5+3 xof_shake256 1 -1597 135546 +121+7-3+3+0+6-3+9-2-4+2+2-3-1-3 xof_shake256 1 -2396 203169 +131+8+8-8+1-3-7+8+0-3+68832+34-4-2-3 xof_shake256 1 -3595 304583 +164+0-6+12-5+5-6-5+8+4+2-3+0-4+45604 xof_shake256 1 -5393 451138 +158-8-8+1+0-3-14-7-3-4+2+11404+1358+1348+1334 xof_shake256 1 -8090 678576 +179+14-5+1-1+10430+10-1+0+0-5+0-1+1+39757 xof_shake256 1 -12136 1018098 +159-4-2-2+11066+1+1-4+0-1+7646+0+0-2+0 xof_shake256 1 -18205 1515743 -1977-2136-2111+15947-2102-2145-2115+7553+12+1+2+40724+0-11+4 xof_shake256 1 -27308 2273491 +186+10712-18-31+39845-14+9375-9-27+7741-20-28+37780+0+9419 xof_shake256 1 -40963 3424269 +2153-8603+31862+936-8614-585-8612+29114+69035+0-4942-13327+39324-8597+1329 xof_shake256 1 -61445 5121355 +25824-6774-8315-16493+27832+210-1173+37706+693-1319-9284+29292+0-1355+26984 xof_shake256 2 implementation unrollround compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 2 0 2383 +40328+190+116-1+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 1 2385 +458+35+18+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 2 2385 +328+0+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 4 2383 +375+34+0+2+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 7 2383 +319+0+4+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 11 2382 +347+35+17+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 17 2378 +370+35+34+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 26 2382 +358+0+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 40 2385 +374+32+32+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 61 2381 +398+0+0+0+0+0+0+0+5+0+0+0+0+0+0 xof_shake256 2 92 2390 +402+34+34+17+47+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 139 4546 +510+90+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 209 4554 +450+33+33+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 314 6720 +472+36+0+20+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 472 8861 +358+52+26+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 709 13156 +373+31+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 1064 17468 +367+45+0+0+0+0+0+0+1+0+0+0+0+1+0 xof_shake256 2 1597 26065 +336+0+0+0+0+0+4+0+0+0+0+0+0+0+0 xof_shake256 2 2396 38954 +361+19+0+0+0+0+0+0+1+0+0+0+0+2+0 xof_shake256 2 3595 58292 +631+17+0+0+1+0+0+0+1+0+0+0+1+0+0 xof_shake256 2 5393 86238 +384+11-5-5+48346+67+30+15+15-4+0-5-5-5-5 xof_shake256 2 8090 129241 +445+26+26+5+0+0+0+0+5+0+5+0+0+0+0 xof_shake256 2 12136 193739 +410+34+35-4-7-2-7-1-2+11595+52+0+1+1-14 xof_shake256 2 18205 288306 +461+55+39-4-7-6-7+0-6+0+1+0+9+10938+50 xof_shake256 2 27308 432337 +414+27+18-8-7-7+0-7-7+45015+8+10-1+0+7 xof_shake256 2 40963 649410 +389+11538-16+1+0-9-9-1-8-4+7893-11+2+8+8 xof_shake256 2 61445 971809 +594+18+11-12-11-1+10311+33+6+0-13-6+9368-1-1 xof_shake256 2 -1 2206 +372+53+34+0+0+3+0+0+0+0+0+0+0+0+0 xof_shake256 2 -2 2213 +325+20+0+0+3+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -4 2226 +298+32+17+0+3+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -7 2245 +330+21+0+0+3+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -11 2271 +302+42+20+0+3+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -17 2310 +304+42+0+3+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -26 2369 +301+41+20+0+3+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -40 2480 +305+41+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -61 2616 +268+1+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -92 2818 +268+1+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -139 4268 +351+76+35+23+3+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -209 4743 +306+29+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 2 -314 6608 +304+19+34+19+23+2+0+0+0+0+0+0+0+0+0 xof_shake256 2 -472 8802 +335+22+0+0+0+1+0+0+0+0+0+0+0+0+0 xof_shake256 2 -709 12656 +338+21+20+0+0+3+0+0+0+0+0+0+0+0+0 xof_shake256 2 -1064 17318 +333+21+0+0+0+0+0+0+0+0+0+0+1+0+0 xof_shake256 2 -1597 25450 +318+1+0+0+0+0+0+0+43193+129+1+0+0+0+0 xof_shake256 2 -2396 37646 +300+2+0+0+0+0+0+0+0+0+0+0+72+0+1 xof_shake256 2 -3595 55950 +314-7-4+8+2+0+0+72+0+0+2+0+0+0+6 xof_shake256 2 -5393 82808 +311-7-4+1+2+0+0+6+2+0+0+6+0+0+0 xof_shake256 2 -8090 123692 +315+0+3+0-1+3-3+1-3-1+5-3+72-3+2 xof_shake256 2 -12136 184985 +383+16-6-2+0-6+8+0-6+66+66-6-2+0-6 xof_shake256 2 -18205 275800 +337+87+68+14-4+10748+70+8-2+0+0-2+0+0-2 xof_shake256 2 -27308 413191 +376+103+0-15+42903+80-5-12-8-5+56+3-12+7-12 xof_shake256 2 -40963 619861 +447+64+24-71-2+0-69-2+9312-3+2-52+74-52+17 xof_shake256 2 -61445 928110 +516+25-25-28+10236+0-99+39-29-102-31+15685+21+29-102 xof_shake256 3 implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 3 0 2149 +2549+109+67+16+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 1 2151 +206+17+16+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 2 2151 +217+18+16+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 4 2149 +243+37+35+33+16+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 7 2149 +190+1+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 11 2148 +214+19+17+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 17 2148 +179+19+16+0+0+1+0+0+0+0+0+0+0+0+0 xof_shake256 3 26 2148 +215+2+0+0+0+1+0+0+0+0+0+0+0+0+0 xof_shake256 3 40 2151 +333+2+0+0+2+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 61 2151 +160+1+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 92 2155 +241+32+31+0+0+4+0+0+0+0+0+0+0+0+0 xof_shake256 3 139 3909 +232+36+34+19+19+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 209 3914 +267+50+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 314 5685 +356+72+2+2+19+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 472 7413 +229+41+19+1+0+1+0+1+0+0+0+0+0+0+0 xof_shake256 3 709 10897 +246+35+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 1064 14392 +332+48+36+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 1597 21368 +258+34+31+0+1+0+0+0+0+0+0+0+0+4+0 xof_shake256 3 2396 31818 +277+36+0+0+0+0+0+0+0+3+0+0+0+0+0 xof_shake256 3 3595 47502 +243+19+3+0+0+0+0+0+0+1+0+0+0+1+0 xof_shake256 3 5393 70165 +277+17+0+0+0+3+0+0+0+3+0+0+3+0+0 xof_shake256 3 8090 105058 +241-7-1+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 12136 157482 +389+46-3-3+0-2+1+0-2+0-4-2+1-3+0 xof_shake256 3 18205 234268 +367+8-1+1+0-1+2+3-1+58663+118-47-48-51-52 xof_shake256 3 27308 351320 +307+151-126+1+0+4-2+0+11339-7-119+3-2-1+0 xof_shake256 3 40963 527492 +245+37+10879-225-142-3+1-5-4+0+0-2-4+2+40463 xof_shake256 3 61445 788920 +316+2+11397+7+14-1-12-6-11-12+8287+0-10+1-5 xof_shake256 3 -1 1994 +184+48+46+28+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -2 1999 +116+77+34+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -4 2011 +137+37+4+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -7 2028 +109+37+15+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -11 2052 +123+32+20+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -17 2088 +123+53+2+0+0+0+0+0+0+0+0+1+2+0+0 xof_shake256 3 -26 2178 +128+20+3+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -40 2252 +112+36+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -61 2410 +91+0+3+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -92 2572 +110+0+3+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -139 4114 +157+23+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -209 4567 +126+17+0+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -314 6480 +99+15+3+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -472 8710 +139+2+3+0+0+0+0+0+0+0+0+0+3+0+0 xof_shake256 3 -709 12676 +177+2+3+0+1+0+0+0+0+0+3+0+0+1+0 xof_shake256 3 -1064 17376 +322+2+0+0+1+0+0+0+0+0+3+0+0+0+0 xof_shake256 3 -1597 25675 +164+2+3+3+0+0+0+3+0+0+0+0+0+0+0 xof_shake256 3 -2396 38122 +151+2+3+0+0+0+0+0+0+0+0+0+0+0+0 xof_shake256 3 -3595 56803 +141-6-5-7-4+39+0+0+0+0+0+3+0+0+0 xof_shake256 3 -5393 84184 +139-3-2-5-1+38+0+3+0+3+0+0+0+0+0 xof_shake256 3 -8090 125882 +124+1-1+0+1+3+0+0+0+11270+39-3-4-2-3 xof_shake256 3 -12136 188407 +202+25-1-4+0-1-4+0+3+0+0+6+0+6+0 xof_shake256 3 -18205 281008 +154+15+10592+33-9-10+32+0+0+0+0+0+0+0-3 xof_shake256 3 -27308 421176 +125-1+43569-22-2-6+0+0+0+0+0+0+0+0+0 xof_shake256 3 -40963 631936 +334+42+3+0+0-8+9153+189-2-8-8-8-8+0+0 xof_shake256 3 -61445 946250 +584+42-2+10323+27+0-13+0-9+7911+23+36-14-10-10 kem_6960119 selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair selected 1047319 3273768370 +1624396538-1027956648+33913096-1559274290+40446642-492217908-1559778392+35703196+559169558+1084509117-528489542-1044991811-523134006+2071842866+0 kem_6960119_enc selected 194 582618 +122546+18909+476395-38087-81123+0+129639-38976-81617-81817+46395+222634-85983+472934-80887 kem_6960119_dec selected 194 1942949 +78449+72896+3333+0+10592-1560-3624+106176-1809-3405+25762-2403-3159+10422-2420 kem_6960119 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119_keypair 0 1047319 2758818874 +695241517+2079849581+4961365+0+155606372-3170308+6219440350-53212569735-690207112-689361190-684793236+2054225780-685459782+2228668-2254673 kem_6960119_enc 0 194 689152 +277634+88596-49542+132864-46828-43838+43498+263948+46562-43214-44598+88738-674+0-44444 kem_6960119_dec 0 194 3544961 +118660+95659-5183+0-10307+29612+35149-15585+694-14725-6449-14498+28550+626-14284 kem_6960119 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair 1 1047319 2235779950 +510798564-531305808+503305564+2052434888-15173924-8193354-527658856+4620647545-524317836-523140516+3672010+3133497704-525449518+0+525531878 kem_6960119_enc 1 194 543066 +219682-46592+16404+135386-41880-41646-41304-38858+216-468+0+1224+1446+166856-35552 kem_6960119_dec 1 194 1956987 +71038+9587+57948-2727-3525+5954-4507-4564+94582+988+0+11886-846-176-6717 kem_6960119f selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair selected 1047319 3736613250 -14459478-15051322-9650520-6421338-11075506-6857079-18694098+1415046+6330712+15073653+5269646+7409046+5036174+9636534+0 kem_6960119f_enc selected 194 591371 +690910+11461-42755-39513-80760+0+11936-80575-40629+85417+40599+1180+128374-85044-2627 kem_6960119f_dec selected 194 1958017 +132980+5213-555+110335+0-1044+10822-5899-6765+3958-13846-14848+40864+134-2160 kem_6960119f 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119f_keypair 0 1047319 3943467136 -8867198+1669870-4265524-3373139+4794506+2510452+0+4136960-2134574-5202878-1800457+148728-2119655+2229248+2175736 kem_6960119f_enc 0 194 698374 +775106-13449-1861+310569-43550+89705-1347-45997-1274+1296+67144+96197-592+304188+0 kem_6960119f_dec 0 194 3546206 +120620+1616+5725+82317-13912+4013-16294-993+29566-16091+0-15782-2874+43868-15016 kem_6960119f 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair 1 1047319 3744903207 +5548084-127327-5325793+0-1555591+4003027-111563-238197+472011+3767783-1102979+1277255-3272891+5926194+254167 kem_6960119f_enc 1 194 594369 +617373+14370-86314-476+85854-84799-82790-83349+167809+0+206649+44711-87142+39856-86657 kem_6960119f_dec 1 194 1957506 +68857+69191+0-3803+4204-5143-5005+76363+1380-13208+13190-5841-14045+4867-5271 kem_6960119pc selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair selected 1047319 3798720898 -1563244144+148695646+1183075338+8614193-1560868762+4178357540-510947673-1036636458-1037121482+0-1564558960-2084028604+3130164831+1261934+1044977033 kem_6960119pc_enc selected 226 560682 +235051-2979-40458-42869+42702+0+14282+299575+41206-46165-47833-45808+294046+81620-44598 kem_6960119pc_dec selected 226 1973305 +122769+9970+6324+96597-3958+0+1528-6832-6675+4352-6064-5211+40359-5565-6278 kem_6960119pc 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pc_keypair 0 1047319 3476661074 +1388547199-693835732-692334775-1392575914-1391657437+0+2088579423-1386356752+697573440+5719499643+9721121550-1391840290-3422666+5602504+5539203008 kem_6960119pc_enc 0 226 749015 +16960-87347+151772-86567-4897+86473+42004-89796-89781-87687+220486+0+129516-88132+87947 kem_6960119pc_dec 0 226 3573661 +127505-2048+96078+5805-13954-437-15225+29869+0-15252+21097-14584+31405+1506-14561 kem_6960119pc 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair 1 1047319 2758357104 -1045346304-1048039645-1044667108+6274682836+1563228156+0-1045717768+1034005619+3119431650+1559168019+5225115900-518038884-524806328+2614830380-2669910 kem_6960119pc_enc 1 226 559729 +159240+55561+53397+749-40616+3168+1011-40146+0-41430+42862-42690-3795-38084-40108 kem_6960119pc_dec 1 226 1972479 +72233+189485+3466-2703+10517-4349-5011+5727-5352-4562+40022-10547+0+11014-3928 kem_6960119pcf selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair selected 1047319 3746804700 +2693528+1695750+230358-2408418-3316139-3490211-5827722+3697414+0-2137144-2124734+3492042+1946916+4973268-2599298 kem_6960119pcf_enc selected 226 566919 +630794-36759-43860+194841-7100+128876+40296+41763-43399+2217-1542-43923-43749+224801+0 kem_6960119pcf_dec selected 226 1973823 +69836+5631+53592-4553+0+90813-5619-1971+3004-2153-537+12934-1335-1981+40789 kem_6960119pcf 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pcf_keypair 0 1047319 3946534626 -4078640+2572523+0-775854-3886942+3709752-685640+128730+1720176-2519640-3157242+2852346+3257886-3962884+576454 kem_6960119pcf_enc 0 226 709436 +362814-55536+84683+0-6571-48346-49669+88569+8327-49573+211819-8015-48742+83626+128715 kem_6960119pcf_dec 0 226 3575501 +64520+47160-11674+87361+2337-14785-1722-14831+28154+0-15323-2564-16975+32028+24131 kem_6960119pcf 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair 1 1047319 3742747692 -3601124+6027295+6630044+824968+199389-1079741+4089660-4768590-6461562-187286+2691374-457924+1576873-437684+0 kem_6960119pcf_enc 1 226 566192 +578298+207373+3218-44604+35303-40932-501+211822+0-43180-254-43077+77318+51130-6157 kem_6960119pcf_dec 1 226 1972712 +89596+66762-398+2382+11235-5008-4090+83267+0-41+10075-6525-1030-996+3780 kem_6688128 selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair selected 1044992 3471274564 +469585655-841679262+468372081-849217815+470202236+0-847028866+2457598824-1503829944+2453413306+6425674718-1506851184+1793515144-180586215-1504163034 kem_6688128_enc selected 208 500929 +225412+204100+175532+128685-43907-43793-44653-45367-45689+88327-43735+88213-39607+270776+0 kem_6688128_dec selected 208 2018435 +88947+52620-18907+3329+13663-11481-13567+89471+2010-13922+14043-12751-238-1571+0 kem_6688128 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128_keypair 0 1044992 3504621726 +878804+2959357506+6877387871-983033218-1083628-2321849+2714091+2945248448-991304664-984443814+9837533851-981642672+0-982127576+4912901952 kem_6688128_enc 0 208 690471 +244358+27811-45881+0-41800-32807-132535-39113-39332+93658+275614-86492+4728+124891+322689 kem_6688128_dec 0 208 3662190 +67897+46078+1236-12344+87383+0-12155+18989-13822+31759-2729-14157-4577-14101+29832 kem_6688128 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair 1 1044992 2624396322 -659232334+0+2644882172+1328872115-4368612-663395962+579462-660550352+4345680-2005024-660172190+656465400+1321421522+1321670710-660019630 kem_6688128_enc 1 208 629402 +324409+111061-181871-132826+1096-172030-172760+47308-86950+0+43500+138475-176513-40576+177414 kem_6688128_dec 1 208 2022050 +78796+68130+2175+0+12230-2371-15883+108115-2624-3210+15748-15927-3465+9519-3035 kem_6688128f selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair selected 1044992 4211726402 +47338294+47775511+26622195-7578950-5133150-3523234+0-3485258+1694658-2055647+1264672+3567612+291670-4708128-382326 kem_6688128f_enc selected 208 552934 +161825-66440+63903-37629+41530-1276-2722+87730+44018+0+88812-44356+349097-45209-88112 kem_6688128f_dec selected 208 2020990 +86789+51188+4206+0+102560-13983-1487+15393-14670-1864+11493-15551-15947+34336-15043 kem_6688128f 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128f_keypair 0 1044992 4274874538 +142786078+156267946+157374478+63165980-2355430+0+2186877-181243-413742+11795552-4269162-3647802-3931600+400912-2535409 kem_6688128f_enc 0 208 658100 +290492-66861+42935+46137+0+907439+137544-17860+39677-3936-5484-6560-51308+265389-4006 kem_6688128f_dec 0 208 3655499 +72048+40103-1875+3956+62187-8312+0-10041-777+32611-10189+900-1323-10276+32918 kem_6688128f 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair 1 1044992 4206076000 -63098260-960398292757+77729345+10312151+3940948-112434+104144+1385086-3667082-7616706+1865350-4039036-5171068+4391672+0 kem_6688128f_enc 1 208 590778 +206289+112627+127750+9123+311799+0-39968-129844-128830-84608-124578+397892-128492+217288-71228 kem_6688128f_dec 1 208 2022187 +87632+7982+64682+0+7413-1366-2650+99026-11912-2519+10711-18041-3911+6289-15910 kem_6688128pc selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair selected 1044992 3299760166 +660051353-1332429856-6389012+663047893+1323974845+2652490620+5322810770-661945254-674136074-670506022-1340089894-670930240+0+1332194579+662739045 kem_6688128pc_enc selected 240 639546 +0-56976-125246+98228+60785+101541-159716-158807-116863+74489-29266+191427+18745+13385-24356 kem_6688128pc_dec selected 240 2033634 +156750+7938+5566+105050-528+0+12059-3132-3574+8288-557-3713+43417-3387-943 kem_6688128pc 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pc_keypair 0 1044992 4480142738 -1006373996-980309410+0+5905403002-981984771+2941456500-980281456+3941957070+1693775-1962685382-1962039018+1974994577+1963941410-2081058+7721361 kem_6688128pc_enc 0 240 616753 +154822+2434+95633+275461-41275-39748+68325+92113-49015+0-43377-47013-2219-46825+133161 kem_6688128pc_dec 0 240 3676473 +123139+99232-8008+7692-1565-12045+27618-11727+2432-1855-11749+24978-12189+1387+0 kem_6688128pc 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair 1 1044992 2632330512 +654570174-5257330-1465404+3981119920+1326142054-659256108+3323323110-657529426+1996508844+3312058764+1333106152-11191974+0-202882314923-655054120 kem_6688128pc_enc 1 240 530751 +172996-32792+67399+73152-61284-57576+0+75527+25292-52392+33738-53355-5672+79183-9955 kem_6688128pc_dec 1 240 2036509 +168402+6329+0+255346-3282-4718+13048-5677-5427+13376-5120-5530+45000-5806+6952 kem_6688128pcf selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair selected 1044992 4203559527 +41369149+11077165-462954-4433864+6548815+1720612-1601595-536615+2923620-1318921-2049342+2442359+187009981-4953690+0 kem_6688128pcf_enc selected 240 565998 +209397-70013+340782+37142-45847-88041+218956-41146+89014+131470-44594+5734-44252+0-87252 kem_6688128pcf_dec selected 240 2033679 +90709+67277+3641+0+100905-8523-3470+15828-2709-3187+6585-541-3115+43734-2290 kem_6688128pcf 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pcf_keypair 0 1044992 4428816000 +2479677-1024878+5010522-86798-4480596+0+744089+6217701+1672586+1727392-10381394-2653729+1657136-2331901-3464738 kem_6688128pcf_enc 0 240 756002 +480530+172225+262610-180803+312-43704+0+47520+171234-191425-2636+41093-183584-186805-138788 kem_6688128pcf_dec 0 240 3679312 +125826+2370-15679+81737-16706+1415+0-17930+21992-10984+293-3198-13754+56515-4120 kem_6688128pcf 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair 1 1044992 4207350855 +186125492-4398597+0-1060645-6622870+788795-5086495-2757675+105854-4725222-5337573+2954215+274304+5312041+4277015 kem_6688128pcf_enc 1 240 690030 +172650-152964+0-212999-129537+5014-68134+52506+4233+8614-78456+141464-164968-35844+483537 kem_6688128pcf_dec 1 240 2033515 +92107+11725+64528-123-1361+11657-2539-3201+101189-1086-3017+8687+0+7632-1575 kem_8192128 selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair selected 1357824 5276725057 +1295380086-2610722965-1311099423+2604640676-2607352765+6697067379+1315259636+10283363-1302007569+2066451+0-1302679387-1302665896-1304492389+2606652749 kem_8192128_enc selected 208 577927 +204539+15145+0+52998+51647+20250+79468+32848-2931-38397-6255-36060-37670-37516-34500 kem_8192128_dec selected 208 1904304 +135763+0-5345+100151-8866-9536+6065-9610-9985+7822+22386+5532-9152+43349-9853 kem_8192128 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128_keypair 0 1357824 9194170234 +5700162076+7812369882+21106450821-1909021041+13311704879-5725883726+0-5720132034-3821330269-5723199052-3818739630-5717564537+3803684928+3792255545+15229462957 kem_8192128_enc 0 208 747999 +174532+159667+8796-29890-28833+0-539-30923+357+106277-16591+2591-29328+63294-31149 kem_8192128_dec 0 208 3605107 +122543+8891-6158+94888-10003+3173+0-10323+34412-11341+1323-1581-11262+33245-11781 kem_8192128 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair 1 1357824 3980504160 -3880206+5239786265-1305945978-3277152+0-1307210016+10464375044-1310887044+7843312596+2606021821-1308460740+3931523523+10461877695+476280-1308720868 kem_8192128_enc 1 208 570174 +255000+141893+43952-31795-4457+86425-34146+84753+25696-3495+0+117738-7534-4908-36851 kem_8192128_dec 1 208 1896768 +81905+67947+3451+0+12427-2713-2858+101231-1083-3511+9513-1291-3469-3762+9082 kem_8192128f selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair selected 1357824 5312072749 +5036743+0+528569+1955148+966551+4044812-4242203+3893464-589839952801-12916448+2283531-5663045-1331680-10348409-5625951 kem_8192128f_enc selected 208 570361 +331863+88278-15192+30521-243-32470-28437+223968-11947+243213-30385+4477+57419-34940+0 kem_8192128f_dec selected 208 1895232 +142669+8966+5703+23788+0-1398+107263-576-1114+13769-1601-954+10819-1651-1530 kem_8192128f 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128f_keypair 0 1357824 5624156313 +6256569-1675660-12297517+1046011-2294371+16033+0+2971493+4052987+4690491-4224373-3711187-6267071+521346-169188 kem_8192128f_enc 0 208 780666 +77987+72332-63152+94473-47635-30470+63253+219179+61945+0+51249-25709-65212-63166-64587 kem_8192128f_dec 0 208 3604157 +120826-2810+94650+3249-10489+0-10633+32207+1547-10374-577-10365+32258+10776-11086 kem_8192128f 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair 1 1357824 5303860560 +3877470-5242193-6296270+1882446-8649056-4314372+0-5520438-87706-2929422+346834+7308656419+9384988+10226950+9740466 kem_8192128f_enc 1 208 611013 +213200+22620-58031+104431-39389+0+8708+23858-41694+43721-11815-13989-71966-10534+105793 kem_8192128f_dec 1 208 1895928 +80485+7607+160962+1784-552+14441-1195-1915+8130+0-2903-2376+45788-2532-2146 kem_8192128pc selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair selected 1357824 2671080446 +0-3502117-7241459-3820684+11774430960-6852804-1935702+1302803548+7850541769-4407534-3771770+1312654193+1295362828+3910610628+5225542946 kem_8192128pc_enc selected 240 636056 +159028+0-70084-20599+10520-53199-48522+10310+107478-65832-85223+9508+71843+2949-54761 kem_8192128pc_dec selected 240 1910000 +151710+9232+3728+16711+0-1396+109097-896-1436+14256-886-1348+9973-2-1586 kem_8192128pc 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pc_keypair 0 1357824 5364624670 +11370898572+5694778004-1893307854-1896124676+0+7587619788-1901092508-1902581204-1894982418-14637466+3787740896+7780446260-1897993052+1894863944+9489792345 kem_8192128pc_enc 0 240 737538 +201359+4822-4133-4479-4332+216050-7226-6240+62373+0+56365+25452+120492-5684-6218 kem_8192128pc_dec 0 240 3637774 +217511+14842-7763+1258+33650-10616+355-12300-776+30328-10267+0-12548-1137+30949 kem_8192128pc 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair 1 1357824 5279634624 +1311181573+4167376+1312217162+10653620907-1309549349+7845438561-2615674034-1304309194-2142806-1306610008+11954652734-1308421812+0+1313487250-1312594583 kem_8192128pc_enc 1 240 589488 +209748+265011+156702+135261+3326+0-7214-30386-32534-7110-37690+83488-5311+50669-18774 kem_8192128pc_dec 1 240 1912752 +82737+6714+67393+0-1668+105982-3822-4536+13881-4197-4485+9775-4317-4600+43228 kem_8192128pcf selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair selected 1357824 5312440671 +120137079+2909726-5956311+0-3921+6375426+1599827-3431861-4772190+689933+4688311+4056255-2508615-7528487-4113359 kem_8192128pcf_enc selected 240 614930 +217958+22692+12852-26746-57063+91807+106932+0+91625-61638-60091-57746-59295-56600+3089 kem_8192128pcf_dec selected 240 1909773 +140771+8980+4484+17052+0-695+105761-331-856+15318-956-1226+36381-671-1417 kem_8192128pcf 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pcf_keypair 0 1357824 5629165072 -8040094-9529222+1596968-3173232-4169818+3000964+1376343+2319960-930140-4602682+2465664-1064434+1274996+0+69884 kem_8192128pcf_enc 0 240 762715 +237713+66333+299+37320-22320+62806-819-30772+0-32066+188184+137746-17721-31129-113 kem_8192128pcf_dec 0 240 3640397 +123946-2358+5848+94098-8635+6108-10720-103+33154-10030+1306-10231+0+32809-10357 kem_8192128pcf 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair 1 1357824 5311617012 +415556-2254178+0-2978600-3186460+4649308+6378156-2202926+5050058+2567190+5769114-2010486-1904922+4793408-4083538 kem_8192128pcf_enc 1 240 605411 +252949+0+139160+163482-48649+225756+56510-46557-49693-50714+43281-43572-22198-51532+40358 kem_8192128pcf_dec 1 240 1911122 +85414+9811+69073+855-954+105251+0-2041+13240-1051-2295-2518+10659-2447-2584 kem_460896 selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair selected 524160 1143842784 -248785194+495043483+0+1980697346+249679084-248093932+2966998700-247453058+2474606490-1167734+248688368-249842280-248483706-246207168+4209726549 kem_460896_enc selected 156 240090 +314387+56360-205-15-638-732-2038-1606+277993+327983+380+0+243134-2106+137754 kem_460896_dec selected 156 1817663 +86935+39376+6149+2208-831+11737-100-20032+56589+0-22721-9720-1094-21072+7072 kem_460896 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896_keypair 0 524160 1558780487 -528927117+0+261026849-530275659-266988509-263554282+263595649+261597535+788641025-264767389+1054063189+525974543-528845437+1053791293-527595419 kem_460896_enc 0 156 347628 +282380+158189-35391-36285-36789+105-416+144625+0-36557+107371-37117-37510+35358+107435 kem_460896_dec 0 156 3311483 +68876+27798-4800+59845-10886+612-11645+5391+36902-10778+0-11494-139-11997+36471 kem_460896 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair 1 524160 1142609970 +742505488-248156898-245725280+0+247830932+497134672-242727454+249052710-243926929-247819973-244822784-246108334+152596+1175916+989501288 kem_460896_enc 1 156 309724 +554737+45396+0-70365+35040-71082+69940-35296+138353-69883+94594-35550-70360-9866+34004 kem_460896_dec 1 156 1817368 +84129+40650+5521-17480-16726+78138-21879-251+11564+0-21074-4163+944+244-20250 kem_460896f selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair selected 524160 868696253 -87564+571782+2231723+1327579+0-1204879+2325753-2034649-1731137-1131100-1524709-3655247+2167287+4622023+6265315 kem_460896f_enc selected 156 273231 +791639+90720+68416-34734+94183+33681+491-34277-455+34163-34334-1242-35529+0-34920 kem_460896f_dec selected 156 1817343 +82515+8906+3488+103509-471-178+14299+0-20277+10232-22266-20504+27706-148-2381 kem_460896f 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896f_keypair 0 524160 1067779534 +2037684+3182080-429510+1346264+2717248-403608-1687640-1918073+877562+314512+0+905960-1300256-1198032-97979 kem_460896f_enc 0 156 408355 +517418-31238+14464-96768+85372+0-34955-63339+10059+139045+12053-97226+47685-97972-97768 kem_460896f_dec 0 156 3310287 +97805+0+75073-8377+2712-10859+17726-10883+39115+602-10515-1398-11503+33571-10211 kem_460896f 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair 1 524160 868752956 +2851698+3058378-887841+0+1128802+3087688+1074840+176634+213390-1137923-2952816-1037127-2117732-1954416-1283096 kem_460896f_enc 1 156 300533 +679770-4105+45790+103226-61493+8309+44054+0-61666-26706-12880-22788+7177+6977-63002 kem_460896f_dec 1 156 1815011 +86451+11058+37964+5103+3544+80751+2042-18433-2122-18843+0-16077-7018-16227-18093 kem_460896pc selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair selected 524160 1640872918 -495415405+1236919458-3638020+990674350-744575194-743432260-745360498-744670320-742475968+742501288+0+1484141302+493734536+743057488+247073834 kem_460896pc_enc selected 188 287280 +433319-13194-30997+299029+139864+0+33805-14-35482-35157-35616+34229-34415+60632+103620 kem_460896pc_dec selected 188 1819689 +192916+6093+2193+0+11152-3264-2359+7698-4345-3185+48045-4820-4578+9213-4539 kem_460896pc 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pc_keypair 0 524160 1556999504 +792717820-264083998+2763940+2348732+264202392-527573284-526144762-263399502-262251704+988390-525004471-526841756+346128426+0+1319426150 kem_460896pc_enc 0 188 355103 +440655+24965-32018-36121+36532-37215+0-36911-275+4822+53893+256525-36038+73156-36871 kem_460896pc_dec 0 188 3313971 +70053+94200+4934-10009-123-11109+34885-11231+663-7735+6699+32854-6722+0-11209 kem_460896pc 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair 1 524160 1392413232 -493018249-494949096+0+2562632-493278228-496365818+2474122284+1506378+497520472-296266-494587637+1238178+743641686-495675778+495662480 kem_460896pc_enc 1 188 328348 +402526+10362-40335-75347-75572-40172+62732-32125+0+63471+91669+158999-5862-76481+27812 kem_460896pc_dec 1 188 1818557 +88903+37545+3131+0+79584-422-2097-2449+11043-1601-1353+9794-2290-1913+44786 kem_460896pcf selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair selected 524160 868873221 +493030+0+2225121-994533-1706317-211281-1852073-4287183-3178035+2557913+3456817+1284921+574813+2239571-603313 kem_460896pcf_enc selected 188 277126 +671667+0-19116+12814-23519-23730-23756+11638-23766+82373+11601-23756-24156+98824+3538 kem_460896pcf_dec selected 188 1817665 +89737+8643+36995+344-308-894+16545+0-1087+84578-1037-848+12053-2046-2024 kem_460896pcf 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pcf_keypair 0 524160 1068276098 +225801-1947422-581652+524840-216713+0+2450172-3614212+188652-47552+80409868-1180304+1659776-2863104+1071370 kem_460896pcf_enc 0 188 428865 +435406-70210-105183-35838-110047-110258+133289+199707-104553+0-72237+36700+26519+1357+27327 kem_460896pcf_dec 0 188 3311046 +105405-2564+26086-8642+63422+6202-3040+0-9318+34150-5796+1119-9682+2169-5938 kem_460896pcf 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair 1 524160 867622314 -34010+2939092+7142808+3812896+1041414-780342-1356814-1792958+2196446+420730-128598-651652-584862+2039262+0 kem_460896pcf_enc 1 188 287514 +648255+92461+108513-364+682+235461+71545-716-35032-35240-9248-35191+353+0-34668 kem_460896pcf_dec 1 188 1817403 +199958+9252+6030+15610-487+0-511+11999-1920-456+50678-2114-1716+11495-1908 kem_348864 selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair selected 261120 376674948 +225543678-135310918+0-45139620+270338022-45200258-135160366+180231262+7476+135039156-45290080+225474910-90252834+90040312-90002038 kem_348864_enc selected 96 141934 +187728-16302-20799+2729-21850+23144+1484+23964-22588+0+451+278-35-22389-22240 kem_348864_dec selected 96 656747 +97439+7069+4017+1199+0-292+67378+4422+67-329-405-576-218-550-154 kem_348864 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864_keypair 0 261120 444243944 +159432-64692356-64661536+194263108-129450834+64989176+64863078+129423772-64722358-129454508+129506190+194367062-129444414-129484169+0 kem_348864_enc 0 96 154172 +216833+92384+1786-513+0-424+46992-541+23076+22727-512-475-639+22739-758 kem_348864_dec 0 96 1201849 +51838+7944+18794+1673+184-979-1035+9609-660-909-1092-1094+51864+0-891 kem_348864 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair 1 261120 286561018 +216485+0-43980-45216542+44999728+180167318+44943488-45200492+44905906+90113894-45189022-45209982-45019242-136342+225413980 kem_348864_enc 1 96 142222 +168849+7080+3343+846-22189-6572-20430+22702+148-22504+0+130-22529-22414-22698 kem_348864_dec 1 96 656678 +100964+6824+3134+1269+384+0+69035+1415-73-245-110-201-5-93-176 kem_348864f selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair selected 261120 253876527 +7606-2697-120291-29004+12087+0-16152-114270+56387+20873-62297+106582+9069+6726-16190 kem_348864f_enc selected 96 142100 +168272+8063+26602+46304+519-22097+0+22370-34-22176-22054-22386-22651-22292+156719 kem_348864f_dec selected 96 656960 +91235+5559+2038+74207+5853+92-114-169+0-188-304-314-419+15859-191 kem_348864f 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864f_keypair 0 261120 334225328 +123153+0-131698+36767-91868-82766+11710+476564+31764-31462-6680-184453+64473+3662-123022 kem_348864f_enc 0 96 154454 +236998+5194+239+46813-791-1162+45613-880-963+51533+0+92261-1045-979-1121 kem_348864f_dec 0 96 1201057 +50677+5287+5048+17633+80-834-1079-1293+65076+0-1231-1198-1247+13793-634 kem_348864f 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair 1 261120 253973990 +22492-83783-63160-29592+25316+22887+76909+207509-17949-60560-72948-19389+111001+42742+0 kem_348864f_enc 1 96 121457 +177349+4097+0-220-1137+20923+154735+879+20875-1853-1704+20583-1759-1547-2039 kem_348864f_dec 1 96 657035 +91816+6440+2257+789+0-233-12+18197-148-207+36-34-236+79-118 kem_348864pc selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair selected 261120 376638344 +90588991+135291379-45075452+0+315419754-134928936+89994344-45200088-90305087-875592910352+406406226+180350188-135279420-135152886+45006488 kem_348864pc_enc selected 128 153168 +161260-16646-19637+2897-21371+1100-2238-21507-22063+22926-22062+189+498+45040+0 kem_348864pc_dec selected 128 666198 +101086+7508+4322+1208+0-91+19468+67-126-136-59-115+80-188-133 kem_348864pc 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pc_keypair 0 261120 444408596 +64872829+194314365+129826035+518219182+0+453211674-115208-64699206-129520820-129405226-64752554-64659072+64799900+258863161-64681330 kem_348864pc_enc 0 128 167480 +155025+0-3350+139707+18196-5922-5730-5665+63290-5091+17611-5609-6003+40848+17505 kem_348864pc_dec 0 128 1212475 +50149+5061+858+18528+110-667-654-729+10902-384-748-725-813+58585+0 kem_348864pc 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair 1 261120 286404742 -44645112+315736206+0+45275454+45140499-44938091-44950465+45238883-57464-44928669-45045415-44898434+270459964+405680+136001386 kem_348864pc_enc 1 128 132911 +204811+3503+0-1060+67246+20753-1622-1610-1848+43064+87513-2010-1925-1923+20414 kem_348864pc_dec 1 128 666755 +116900+7211+3658+1243+394+0-260-296+12627+2012-643-314-410-134-480 kem_348864pcf selected implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair selected 261120 253935186 +0+18935-24799+115670+85990+62290-169246+37508-30972-2058-97082-17593+90067-110266+75712 kem_348864pcf_enc selected 128 131844 +179778+75720+0-343-501-363-569+21767+21877-711-819+21833-664+67124+22053 kem_348864pcf_dec selected 128 666454 +92914+6646+2310+882+25657+0-157-112-217-339-267-283-463+77105+686 kem_348864pcf 0 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pcf_keypair 0 261120 334263503 +337741-25432-90+116917+42211+186819-60197+0+10319+117348-55980-111105-38222-16105+99633 kem_348864pcf_enc 0 128 162596 +146858+6629+52018+67240+26926-190-172-141+0-8+22821+70053-288-384-108 kem_348864pcf_dec 0 128 1211371 +44957+5380+2240+16792-1687+0-45+23917-190-152-171-249+47591+2004-170 kem_348864pcf 1 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: aarch64-unknown-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair 1 261120 254068008 +165972-258278+340566-3320-97696-106362+42464+101324+8846+155835-69484-238421+447496+0-93842 kem_348864pcf_enc 1 128 131132 +208355+95738+367+22717+0-166+44542-412-220-276-139-27+44682+66860-238 kem_348864pcf_dec 1 128 666609 +94604+7090+83660+1599+350-232-501-179-265-407-455+15057-310+14+0 libmceliece-20230612/benchmarks/samba0000644000000000000000000044174214441554466016062 0ustar rootrootmceliece version 20230219 mceliece arch amd64 cpuid 756e6547 6c65746e 49656e69 65746e49 2952286c 6f655820 2952286e 55504320 2d334520 30323231 20357620 2e332040 48473030 0000007a 00000000 000506e3 04100800 7ffafbff bfebfbff 00000000 029c6fbf 00000000 bc002e00 00000000 00000000 00000121 2c100800 0000001f 00000000 00000000 00000000 00000000 cpucycles selected persecond 3000000000 cpucycles selected implementation amd64-pmc cpucycles selected 0 48 +48+22+22+22-4-2-4-4+0-4+0-4+0-4+0 randombytes selected 0 62 +909+45+22+21-11-8-7+0-4+0+0+0+0+0+0 randombytes selected 1 127 +662+47+6+6+0-3+0+1-3-3+1+2+0+0+0 randombytes selected 2 126 +42+7+8-1+0+0-1+4-1-1-1+1-2+0-2 randombytes selected 4 131 +17+2+2+5-4+0+5+2-2-2-2+5-2-2-2 randombytes selected 7 129 +9+4+5-1+5-1+0+4+0+0+0+7+0+0-4 randombytes selected 11 129 +17+3+8-4-5-6-4+3+0+0+0+7+0+0+0 randombytes selected 17 129 +8+4+6-4+1+7+0+4+0+0+0+0+0+0+0 randombytes selected 26 124 +23+10+10+0+8-1+0+3-1-2+0+1-1+0-1 randombytes selected 40 128 +18+4+8-1+2+1-3-3-2-3-4+1-3+0+1 randombytes selected 61 129 +9+3+7-1+9-1-4+3-4-5-1+3-1+0+0 randombytes selected 92 129 +8+3+6+2+7-3-1+4+0-4-8-6-5-1+0 randombytes selected 139 135 +3-2-4-1+0-4+0+0+0+0+0+6+0+0+0 randombytes selected 209 134 +32-1+0-2+0+0+0+5+0+0+0+2+0+0+0 randombytes selected 314 123 +41+2+2+0+1-1-1+5+0+0+0+3-1+0+0 randombytes selected 472 127 +15-3+1+1+0+0-1+4+0+0+0+0-1+0+0 randombytes selected 709 117 +6+9+3+3+5+0+0+4+0+0+0+3+0+0+0 randombytes selected 1064 120 +47+8+0+0+0+0+0+4+0+0+0+2+0+0+0 randombytes selected 1597 126 +45+0-2-4+36+141+79+5+0-1+36+0-1-1+36 randombytes selected 2396 162 +20-1+1-1-29+2-1+0-31+0-1+3-30+0+0 randombytes selected 3595 176 +5+7-4+0+1-2+0-2+1-2+0-2+1-2+0 randombytes selected 5393 173 +0-6+1-1-1+0+1+2-1-1+1-1+2+2+2 randombytes selected 8090 189 +7-3-8+75-14+5-1-1+0+3+1+5+0+0+0 randombytes selected 12136 176 +16+9+11-2+0+0+2+2-3-3+48-6-2-1-2 randombytes selected 18205 182 +5-8+64-14-7-11-4-1+81+1+12+15+0+2-36 randombytes selected 27308 183 +6-10-11+111+5+5+1-30+4-5-5+68+0-11-9 randombytes selected 40963 184 -42+9+61-15-13-32+3+15+77-2-3-29+7+0+76 randombytes selected 61445 180 -30+18+82+0-32+11+70-4-33+85-4-27+5+105-9 sort_int32 selected implementation avx2 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 selected 0 65 +2283+96+50+22-8-1-3+0-3+0-3+0-3+0-3 sort_int32 selected 1 63 +49-4+1+0+0+1+0+1+0+1+0+1+0+1+0 sort_int32 selected 2 67 +145+42-3+0-3+0-3+0-3+0-3+1-3+0-6 sort_int32 selected 4 67 +89+72+32+3-2+0+0-1-1+0-1-1+0-1-1 sort_int32 selected 7 84 +92+67+46+16+8+0-3-3+1+0-1-1-3-3-3 sort_int32 selected 11 158 +4326+42-1+0+0+0+0+0+13+0+0+0+0-1+0 sort_int32 selected 17 248 +379+86-2+8+0-2+0+0+0+0+0+0+0+6+6 sort_int32 selected 26 253 +21+17-1-7+0+2+4+0-5-4-7-7-7+2+4 sort_int32 selected 40 347 +2147+91+19+0+0+0+0+0+0+4+0-6-4+0-7 sort_int32 selected 61 359 +26+10+1-7-5+0+0+0+9+0+0+0+0+0+0 sort_int32 selected 92 663 +1444+208+9+0-9-7-7-2-7-7+3+0+0+3+0 sort_int32 selected 139 1447 +2073+387+15-3+16+2-4+1+3-1-4+0-4-7-5 sort_int32 selected 209 1474 +286+105+13+2+5-5-8-1+0-2-13+2-13+8-17 sort_int32 selected 314 2132 +2149+295-1+108+77+73+3-24-20+47-19-9-11+0-16 sort_int32 selected 472 3397 +998+257+35+19+2-10-11-16+22+0-19-21-2-15+5 sort_int32 selected 709 5123 +3216+1104+155+36-8-19-24+13-23-41+38-29-6+0+10 sort_int32 selected 1064 8829 +3976+1531+616+229+48-4-59-48-62-76+2-23+4-50+0 sort_int32 selected 1597 13145 +1993+528+263+60+107+4-18+0-105+33-82-11-27-8-34 sort_int32 selected 2396 21196 +4526+1403+709+366-75+70+0+16-57+109-243-230-49-305-211 sort_int32 selected 3595 33043 +2363+1159+512+549+282-85-65-50-191-113-105+0-137+32+24 sort_int32 selected 5393 49777 +4496+1821+540+132+0-211+80+66-91-88-294-159-102+38-273 sort_int32 selected 8090 82365 +3505+1793+908+453+174-5-24-142-183+0-9+1591-1-162+25 sort_int32 selected 12136 142200 +4311+946+344-253-412-677-544-225+618-493-462+0+119+174+341 sort_int32 0 implementation avx2 compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. sort_int32 0 0 62 +2061+49+24-2-1+2+1+0+0+0+0+0+0+0+0 sort_int32 0 1 62 +64+24+0+2+1+1-1-1+0+0+0+0+0+0+0 sort_int32 0 2 64 +530+76+24-2+0-3+0-2+0-3+0-3+0+1+3 sort_int32 0 4 81 +1017+76+21-2-2+36+1+0+0+0+0+0+0+0+0 sort_int32 0 7 131 +610+146+129+13+0-1-7+0-7+0-7+0-1-2-6 sort_int32 0 11 168 +1114+59+5+5+13+26-1+0-1+0-1+1+0-1+0 sort_int32 0 17 276 +588+155+66-3+1-1+1-1+14-1+1-2+0-2-1 sort_int32 0 26 293 +131+54+7+0+0+0-2+1+8+0-4+0-3-4-2 sort_int32 0 40 443 +3381+201+38+3-9-8+36-3+0-5+0-7+0-7+0 sort_int32 0 61 494 +219+44+10-2-3+0-2+0-5+3-6+1-1-3+1 sort_int32 0 92 903 +2820+225+56+34+36-12-6+3-4-2-4-1+0-4+3 sort_int32 0 139 1744 +1899+403+72+54-8+1+0-11+2-13+0-5-8-9+31 sort_int32 0 209 1906 +433+45+18+12+5+11-11+0-14-21-12-20-15+7-14 sort_int32 0 314 2231 +2543+498+88+27-27+1-21+0-16+20+3-12-37-4+0 sort_int32 0 472 3855 +1106+440-23+0-48-14+20+12+31-25+16-30-6-2+37 sort_int32 0 709 5969 +3251+1216+522+92+51-54-6-62-53+29-78-27+0-2+65 sort_int32 0 1064 8486 +4448+1948+615+294+154+102+131+0-62-72-70-48-112-60-47 sort_int32 0 1597 13312 +2358+892+333+205+101+82-86-38-62+36-68-11-61+0-48 sort_int32 0 2396 20848 +4802+1712+678+149+1-106+30-56+0-85+69-68+0-66-122 sort_int32 0 3595 32661 +2506+958+531+269+184+22+0-111-122-27-48-93-116-6+9 sort_int32 0 5393 52931 +5506+2209+1167+876-32+13+0+133-174-284-364-347-332+536-390 sort_int32 0 8090 86857 +3881+1495+661+391+73-173-271+231-153-50+120-110-258+0-78 sort_int32 0 12136 142283 +4299+875+449-129-194+131+94+49-700-862-451+0-858-227+613 sort_int32 1 implementation avx2 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 1 0 63 +288+26-5+0-1+1+0-1+2-1+2-1+2-1+2 sort_int32 1 1 64 +71-5+0+0+0-2+0-2+0-2+0-2+0-2+0 sort_int32 1 2 67 +57+18+19-2+0-3+0-3+0-3+1-3+0-6-3 sort_int32 1 4 67 +72+27-1-2+2-3+0-2+5+2+0-2+2-3-3 sort_int32 1 7 85 +55+38+39+36+8+8+3+0-3+0-4-4-2-4-2 sort_int32 1 11 158 +296+94+0+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 1 17 251 +184+105-5+0-3-3-3-3+7+4+6+6+0-3-3 sort_int32 1 26 255 +19+5+0-6+0-6-6-6+4-6-7-6+0+2+2 sort_int32 1 40 347 +575+138+21-4+0+2-2-3-2+2-2-3+1+1-2 sort_int32 1 61 359 +47+6+1-1-2+0-2+4+7-1+4+0+0+4+0 sort_int32 1 92 664 +661+196+35+2-1+3+4-2+19-7-1-5+0-6-4 sort_int32 1 139 1463 +793+162+67+15+14+5+1-8+0-8+0-19-12-11-14 sort_int32 1 209 1474 +329+131-4-2+9+18+6+3-11+0-14+1-13-19-16 sort_int32 1 314 2189 +920+172+0+0-50+8+16+11-50+15-48-74-46-52+3 sort_int32 1 472 3397 +757+93-16-11-15+1-10-4-7+42+12-6+0+14+19 sort_int32 1 709 5137 +1635+582+39+60+94-17+1-15-39-68-47+7-22-16+0 sort_int32 1 1064 8879 +1843+718+477+127+5+18-19+0-52+12-56-104-63-114-85 sort_int32 1 1597 13204 +1226+409+129+116-173+0-106-120+11-37-18+0+10-118-6 sort_int32 1 2396 20931 +2537+996+424+272-11-81+69+73+16-74-39-45-50+0-29 sort_int32 1 3595 33086 +1865+863+134+107+82-38+0+136+197-131-33-52-232-217-221 sort_int32 1 5393 49683 +3115+1295+451+229+449+187-25-177-30-23-248-185-155+0+10 sort_int32 1 8090 82327 +2808+1255+650+479+0-4-160-215+10-140+38+9-84-31-335 sort_int32 1 12136 141682 +3299+2425+313+453+276+685-110+474-551-132-349-435-388-22+0 sort_int32 2 implementation portable4 compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. sort_int32 2 0 57 +488+68+44-5+1+1+0+0-1+0-1+0-1+0-1 sort_int32 2 1 56 +80+21-5-2-3-2-2-3+0+0+0+1+0+0+1 sort_int32 2 2 69 +201+48+0+0+0+0+0+0+0-1+0+0+0+0+0 sort_int32 2 4 110 +225+166+46+70+0-2-5-2-7+47+71-7-6+0-8 sort_int32 2 7 185 +529+253+68+2+1+0-2-2+0-3-2+3-1+1-2 sort_int32 2 11 331 +890+429+213+82+25-4-2-5-1+4-4-6+0+1-5 sort_int32 2 17 559 +1479+832+348+124+115+110+44-3-4-2+0-4-1-5-3 sort_int32 2 26 979 +1735+797+667+355+291+202+113+0-15-15-19-17-20-16-15 sort_int32 2 40 1798 +2043+896+295+117+17+32+0+7-81-83-77-53-81-86-82 sort_int32 2 61 3106 +2251+821+208+126+78-5+3+0-18+67-38-99-84-104-55 sort_int32 2 92 5381 +3157+964+345+74-16-5-32-13-11-6+32-13+41+4+0 sort_int32 2 139 9793 +4044+1404+777+584+210-50+43+10-52-72-103-79+0-91-184 sort_int32 2 209 16828 +3660+1695+978+641+209+226+9-62-15+0-181-234-198-271-199 sort_int32 2 314 29076 +4057+1612+841+521+134+143+17+0-79-166-176-129-106-181-171 sort_int32 2 472 48295 +1524+982+533+237+145+60-68+86-53-18-105+0-52-79-118 sort_int32 2 709 83489 +5022+2079+958+453+228+143+217-136-227-181-226+0-60-289-91 sort_int32 2 1064 137808 +4840+2414+1840+868+662+224-105-51-80-146-43+0+162-44-3 sort_int32 2 1597 234668 +2308+997+430+63-114+142+47+54-213+0-185-317-201-261-579 sort_int32 2 2396 396211 +2907+1882+1437+1161+716+60-10-237+0-104-606-106-186+59-45 sort_int32 2 3595 651796 +3192+1113+1125+826+1753+190+557-634-556-819-822-583-844+0-556 sort_int32 2 5393 1116461 +4573+5170+1344+4072+266+397-1383-739-1635-883-1315-1927-1365+0+478 sort_int32 2 8090 1825214 +413+3978-200+134+2617-1511-1632-1395-1005+2979-2397-23+0+2420+2189 sort_int32 2 12136 3174414 +255+6254-1263-1202-1052-2626+3223+255-880+1972+1246-658+0-2321+1561 sort_int32 3 implementation portable4 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 3 0 55 +540+49+21+24-1+0+1+0+0+1+0+0+1+0+0 sort_int32 3 1 56 +26+21-5-2-1+0+2+3-2-1+0+0+0-1-1 sort_int32 3 2 73 +444+56+6-1+52-1-1-1+0+0-1-1+2-1+0 sort_int32 3 4 114 +340+119+5+2+2+0+0+1+0+0+0+1+0+0+0 sort_int32 3 7 226 +674+261+51-1+0-1+0-1+0-1+0-1+1+3+4 sort_int32 3 11 411 +1008+300+58+25-1+0-1-2-2-1-2+0+0+3-1 sort_int32 3 17 627 +1487+616+220+23+0+0+0+0+4+0+0+0+0+0+0 sort_int32 3 26 1182 +1748+720+230+243+54+73+69+0-70-70-70-40-70-70-70 sort_int32 3 40 2023 +2198+944+233+161+73+0+0+1+0+0+0+0+1+0+0 sort_int32 3 61 3445 +2574+972+146+22-2+30-3-2-2+0+27-3-3+3-1 sort_int32 3 92 6408 +2845+929+142+146+77+30-5+0+22-41-118-88-114-115-89 sort_int32 3 139 10665 +4825+2474+895+742+426+221+152+0-71-71-72-38-61-61-61 sort_int32 3 209 18400 +4153+1925+1415+554+92+79+58+0-67-59-70-65-31-82-60 sort_int32 3 314 31478 +5271+1943+979+383+90+62-4+29-10+0-39-81-81-63-47 sort_int32 3 472 51664 +2333+1196+387+68+0+31+18-41-24-13+55-80-37-80-10 sort_int32 3 709 89830 +6268+2636+952+376+135+149+79-74-99-214-113-290-149-224+0 sort_int32 3 1064 146534 +6384+2425+975+613+284+2-152-97-48+224-44-55-81-50+0 sort_int32 3 1597 252043 +0-940-1838-2036-2504-2587-2617-2021+2242+2052+2065+2082+1930+1940+2013 sort_int32 3 2396 417871 +5024+2787+1792+1008+292-135-16-224+27+47-259-81-166+0-109 sort_int32 3 3595 679766 +4217+2855+910+688+196+72-283-389+165-75-309-262-382-58+0 sort_int32 3 5393 1143686 +8639+5028+2526+2263+723+272-15-70-80-34+888-190-132-180+0 sort_int32 3 8090 1837546 +5072+3064+1375+879+22-232+0+331-355-491-736-445-228-794+148 sort_int32 3 12136 3135349 +3448+1354+1634+410+808-534-482+0+86-346-777-501+87-61-613 sort_int32 4 implementation portable4 compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. sort_int32 4 0 55 +474+48+21-5-1-2-1+0+0+0+0+0+0+0+0 sort_int32 4 1 57 +28+28-6+0-1-2+0+1+2+0+0+2+1+0+1 sort_int32 4 2 68 +117+68-1-1+0+2-1+2-1+2-1+2-1+2-1 sort_int32 4 4 107 +255+113+6-3-5-4+3+0-5-3+6+1-5-4+3 sort_int32 4 7 189 +584+310+65-1-1+0+0-1+1+1+0+0+61-1-1 sort_int32 4 11 349 +902+572+194+43-1+0-1+0-1+0-1+0+0-1+0 sort_int32 4 17 591 +1539+872+367+154+107+42+2-2+0-2-1-2-1-1-1 sort_int32 4 26 1280 +1838+536+170+83+59+50+46+0-119-189-190-188-190-190-190 sort_int32 4 40 2027 +2546+974+172+0+0+0+0+0-1-1-1-1+0-1+0 sort_int32 4 61 3506 +2270+965+355+113+21-1-2+0+1-1+0+0+1-1+0 sort_int32 4 92 6453 +3470+1365+529+163+41+22-3-1-3+0-1-1-2+0-1 sort_int32 4 139 11358 +4431+1755+870+504+160+59+4+0-96-189-253-275-281-224-271 sort_int32 4 209 19668 +4612+2506+1486+931+639+361+33+0-75-40-87-123-99-92-82 sort_int32 4 314 34106 +4880+2181+828+324+70+0+14+0+77-143-207-212-149-211-188 sort_int32 4 472 57127 +2381+1419+864+575+287+118+94-89-69+0-44-53-76-39-29 sort_int32 4 709 98056 +7109+3538+1586+929+492+127+0+56-108-122-113-114-145-109-108 sort_int32 4 1064 161631 +5473+2373+1443+1206+976+1491+502+0-441-378-268-454-216-324-140 sort_int32 4 1597 272490 +2692+1278+945+153+0-592-293+712+801+430-391-559-436-462-607 sort_int32 4 2396 456802 +4666+2301+896+736+0+677+254-468-533+310-662-873-783-844-791 sort_int32 4 3595 746858 +3712+1481+2342+829-53+100+29+0-823+23-552-1023-1104-1209-1285 sort_int32 4 5393 1248206 +6625+5029+1813+1995+1835+1459+0+140-124-389-351-113-1029-826-334 sort_int32 4 8090 2016963 +2969+4171+4904+1974+830-29-329-913+176+0-702-792-896-352+424 sort_int32 4 12136 3418048 -19718-18437-17452-18909-17529-19357+1945+823+865+1064+0+3027-1312+1900+1857 sort_int32 5 implementation portable4 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 5 0 57 +1472+47+43-3+1+3+0-2+0-2+0+0-1+0+0 sort_int32 5 1 56 +61+22-5-3-3-3+1+0-2+0+0+0+0+0+0 sort_int32 5 2 70 +426+61-1+51-4+4-4+0-3+0+1-3-3+0+1 sort_int32 5 4 115 +324+137+1+0-1+0-2+0-3-3+4-3-3-1+4 sort_int32 5 7 204 +603+219+64+5+5+0-1-1-1-4-1+5-2+3-1 sort_int32 5 11 357 +912+317+132+70+26-4-5-1+1-2-4+7-3-1+0 sort_int32 5 17 585 +1377+676+92+1+2+4+0+49-3-1-2-6-1-5-4 sort_int32 5 26 969 +1718+721+296+278+289+112-7-3-1+36-8-10-9-5+0 sort_int32 5 40 1738 +2281+921+331+128+46-4+28-9+0+23-56-46-41-55-55 sort_int32 5 61 2886 +2626+720+132+133+111+51-7+1-21-23-3-7-1+0-13 sort_int32 5 92 5203 +3200+1114+320+199+85+30-14-6-10-10-17+27-10-5+0 sort_int32 5 139 9329 +4594+2301+638+346+107+49+15-12-29-16-37+0-24-41-22 sort_int32 5 209 15750 +4341+1244+390+103-31+25-10+43+0-16+21-22-37-91-96 sort_int32 5 314 27521 +5066+2169+675+431+180-1-17-59-31+0+7-41-49-18+40 sort_int32 5 472 45204 +2251+1344+452+146+37+0-35-24-132-44+39-60-80+29-78 sort_int32 5 709 79110 +6404+3207+1092+558+350+15+48-150-117-126-111+0-281-50-42 sort_int32 5 1064 131163 +5516+2551+1680+914+549+514+164-32+0-13-114-39-169-131-138 sort_int32 5 1597 224589 +2220+1107+314+182-165-160+31+0-63+29-64-4+79-183-148 sort_int32 5 2396 381469 +4026+2158+1118+927+129+4-305+0+223-343-47-368-312-754-371 sort_int32 5 3595 626247 +5571+2892+1591+1180+169-68-247-17+0-314-91+728+41-633-80 sort_int32 5 5393 1075730 +7030+4465+1734+1903-93+225+831+0-424-344-193-37+226-294-260 sort_int32 5 8090 1747212 +5227+4553+1018+813-731+1621-588-190-2-1047-520+0+679+440-567 sort_int32 5 12136 3050323 +2113+2170+650+1571-347-1440-1291+186+137+616-1012-215+0-1108-322 xof_shake256 selected implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 selected 0 1674 +7195+287+0-1+2+1+8+0+18-3+0-3-6-5-1 xof_shake256 selected 1 1676 +210+58-4+7-4-5+0-1+39+1+1-5+0-4+2 xof_shake256 selected 2 1707 +115+7-2+0+3+21-5-7+15+7-7+1-1-1-5 xof_shake256 selected 4 1702 +208+106-20-27-28+3+1+0+24+9-1-2-1-3+3 xof_shake256 selected 7 1678 +98+13+5+1-5-5-8-7+16-2+0-7-6+29+31 xof_shake256 selected 11 1692 +116+49+14+6+0+1+0-2+0-1+16-2-1+7-1 xof_shake256 selected 17 1705 +80+21+14+4+3+4+1-14+0-21-18-16-20-18-13 xof_shake256 selected 26 1690 +131+12-4+2+1+0+0+0+14+0-4-5-6-7-3 xof_shake256 selected 40 1671 +148+117+43+25-3-1+3+1+13-5-3+0-3-5-2 xof_shake256 selected 61 1696 +65+9-1+37-5-2+0+5+18+9-5-5-3-1+1 xof_shake256 selected 92 1702 +218+105+27+9-4-4+2+0+15-8-6+0+11-6-8 xof_shake256 selected 139 3120 +536+88+9-10+0-4+19-3-1-2-5+0+13-7+11 xof_shake256 selected 209 3118 +140+31-7-5+14+3-6+0+3-8+2-9+17-2-2 xof_shake256 selected 314 4572 +187+107-12+4-11+0+7+3-1-9-3+13-14+4-2 xof_shake256 selected 472 5975 +262+28-13-13-8+27+0-11+5+1+4-4-8+5-16 xof_shake256 selected 709 8868 +177+53-15-13+5-23+0+2-7+0+5+15-17-13+4 xof_shake256 selected 1064 11729 +158+64+14-21+22+13+11+18-2-17+0-14-2-17+0 xof_shake256 selected 1597 17407 +196+31+10+31-13+6-16-17-12+21+0-15-13+3-21 xof_shake256 selected 2396 26009 +169-1-21+0-15-32+1-18+14+2-11-27+35+12+2 xof_shake256 selected 3595 38875 +97+46+18+82+50-41+0-38-11-29+8-52+16-16-11 xof_shake256 selected 5393 57466 +158-16-40+67+14+0-24+6+59+27-26-36+0+27-26 xof_shake256 selected 8090 86048 +64+104-86+36-48-66-5+91-44+12-52+24-42+35+0 xof_shake256 selected 12136 128899 +239-2-55+13+0-48+49+74+16-54+15-44-42-79+708 xof_shake256 selected 18205 191594 +460+0+85-2-87+7+16+40-36-44-34+17+148-20-36 xof_shake256 selected 27308 287567 +289-74+0+80+7-136-107-67-111-65-70+6+74+725+222 xof_shake256 selected 40963 432226 +231+36+181+114-9+37-119+28+0+33-73-109-1-74-133 xof_shake256 selected 61445 646923 +146+147-259+0+116-39+114-104+463+104-261-29-105-197+139 xof_shake256 selected -1 1507 +285+154+0-2+1+0+0+2+6-2+0-2+0+0+1 xof_shake256 selected -2 1511 +145+79+0-1+0+10+0+0+8-1+0+14+7+0+0 xof_shake256 selected -4 1520 +164+74+19+1+0+0-1-3+5-1-2-1-2-1+25 xof_shake256 selected -7 1531 +151+71+23-2+0-2-2-1+5+3+4+0-2-2-2 xof_shake256 selected -11 1549 +125+47+17+0+4-5-3-3+4-4-3-3-3+3+1 xof_shake256 selected -17 1579 +129+43+36+12-7-2-2-6+4-1-6+2-8+0+5 xof_shake256 selected -26 1621 +147+80+64+3-3-3-1-1+4-4+0-1+5-1+28 xof_shake256 selected -40 1692 +116+74+22+0-3-4-4-5+1-3-3+2+5-4+4 xof_shake256 selected -61 1799 +94+26+21+20+34-5+7-3+7-6-5-7+0-6-3 xof_shake256 selected -92 1952 +100+47+21-2+0-5-1-5+3-4+4+13-4-1+2 xof_shake256 selected -139 3072 +412+123+56-4-8-8+29-4+2+4-9-10+0-6+4 xof_shake256 selected -209 3410 +142+6-1-3-5-2-5+10+2-2+0+0-3+1+0 xof_shake256 selected -314 4898 +175+24+0-6-7+3+4+2+1-5-7-10-12+14-7 xof_shake256 selected -472 6678 -15+32+17-5+0+1-4-6+2+1-6-1-8+1+35 xof_shake256 selected -709 9600 +9+22+12-3-9-15+2-1+0-19-7-6+1+6+11 xof_shake256 selected -1064 13140 +20+61+38+0-13+2-22-6+0-7-7+10-16+6+95 xof_shake256 selected -1597 19351 -90-2+7+8-46-2+0-46-21-32+101+81+111+67+139 xof_shake256 selected -2396 28628 -89+2-39+35+0-32-12-7+0-12+0-29+22+6+3 xof_shake256 selected -3595 42559 -82-28-29+9+7+4+8+11+0+2-26-24-32+0-15 xof_shake256 selected -5393 62899 -34+57+92-61+21-2+8-41+16-19+0-9+17-36+38 xof_shake256 selected -8090 93907 +79-179+0-74+4-48-13+41-86+4+48-68+885-145+25 xof_shake256 selected -12136 140412 -41+28+26+0-47-59+66+18-48+34-49-37-18+52+25 xof_shake256 selected -18205 209404 -19+132+27-51+101+0-102-21+76-84+109+9-78+245-52 xof_shake256 selected -27308 313497 +168+147+0-89+28-23+70+135-52-11-79+17-108+92-13 xof_shake256 selected -40963 470469 +271+125+14-126-54+1005+0-50+127-30-5+75-43+23-64 xof_shake256 selected -61445 704421 -22+541-57-332-179+256+47+28+222-44-169+12+253-205+0 xof_shake256 0 implementation tweet compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 0 0 16285 +3372+1210+354+57+59+0-162-46+50-104-117-115+91-29-61 xof_shake256 0 1 16287 +342-51-16-62+0-45-84-22+32+8-49+60+118+48+29 xof_shake256 0 2 16308 +280+103+16+45+0-38+9-21+8-85+5-38-17-119-254 xof_shake256 0 4 16255 +288-6-72+0+65-82+0+14-91+57-23+181-47+67-66 xof_shake256 0 7 16351 +280+31+194+9+27-99-27-22+8+170+0-56-272-76-95 xof_shake256 0 11 16335 +223+262+68+0-98-101+148-42+122+10-126-57+16-47-37 xof_shake256 0 17 16331 +468+157+84+88-24+0-21+108-11-45+78+96-80-64-25 xof_shake256 0 26 16397 +251+186+108+145+100-82-99+0-18+20-59-53+29-69-161 xof_shake256 0 40 16368 +158+201-42-173+0-102-36+38+21+63-49+16+50-56-37 xof_shake256 0 61 16347 +226+135-27+65-88+23+52-27-73-35-5-3+0+10+20 xof_shake256 0 92 16440 +236+29+64-46-66-22-22-51+22+140+0-23+120+40-35 xof_shake256 0 139 31858 +545+69+60-75-116+0+80-66-15-21-245+67+56-37+51 xof_shake256 0 209 32020 +92+19+26-99+149-33+106+61+287-60-157-131-113-38+0 xof_shake256 0 314 47560 +35-6-123+114+114-146+137-34+123-61+178+0+35-269-113 xof_shake256 0 472 63236 +298+108+1+476+65-139-91+0+6-314-47+302-149-104-487 xof_shake256 0 709 94085 +198+88+166-56+14-418-2+96-85+0+52-470-250-84+103 xof_shake256 0 1064 125639 +251+5+337-379-50-248+177-30-340-245+185+0-463+51+23 xof_shake256 0 1597 187783 +1089+249+167+63-57+88-135-112+0+687-395-1+264-729-259 xof_shake256 0 2396 281438 +639+76-293-90-609+72-57+561-188+307+17-492+284+0-301 xof_shake256 0 3595 421085 +464-579+49-158-372-217-396-883-258+223+0+30+59+1353+547 xof_shake256 0 5393 624758 +368-136+0-338-305+393+217+437+289-369+108-448+731-203-396 xof_shake256 0 8090 934780 +167+354+0-369-630-76-97+1304-562+1272-529-787+1959+2234+447 xof_shake256 0 12136 1402502 +301+810-1082-993+633+720-1297+23+184-2876+232+0-671-306-1471 xof_shake256 0 18205 2087677 +1386+116+0-1301-3227-5537-3873-6295-5485+1089+1691+2228-118+2681+2573 xof_shake256 0 27308 3132893 -781+193-1693-4652-3789-4279+0+347+1070+3528+7941+4524+4389-263-10470 xof_shake256 0 40963 4695385 -6538-5579-812+2812+4623+4846+4003+2593+2135+3560-2988+0-3412-5792-8038 xof_shake256 0 61445 7025765 +876-762+4880+807-1103+0-1971-2186+377+762+728+22-1457-7828-10955 xof_shake256 0 -1 16230 +351+136+143+5-22-11-32+11+0-57-34+45-1+68-9 xof_shake256 0 -2 16293 +340+66+35-26+32+12-41-10-70+16+0-64+115-52-110 xof_shake256 0 -4 16313 +242+136-34-35-11+39+39+15-69-134+0-141+15+4-116 xof_shake256 0 -7 16253 +431+27-78+16+58-53-126-69-38-149+7-119+4+32+0 xof_shake256 0 -11 16286 +346+52+16+12-135+27-188-154-112+78-3+0+54-77-36 xof_shake256 0 -17 16278 +325-29+0+69+113+16-105-129-61+118-190+43-70+81-49 xof_shake256 0 -26 16306 +384+283+103-109-63-1+0+0-52+108+21+89+66-4-97 xof_shake256 0 -40 16434 +425+210+313+159+117+103+0-44-253+24-113-108-247-109-191 xof_shake256 0 -61 16408 +280+32+61-128-72+119-31-66+0+67-56+14-3+36-57 xof_shake256 0 -92 16383 +322-22-16+0+23-43-68-107+64-64-21+70+3+47+114 xof_shake256 0 -139 32195 +300+57+105-13+46+43+181-144-81-54+0+97-73-263-249 xof_shake256 0 -209 32208 +404+13-142+0-96-204+54-181-108+47-200-287+70+132+83 xof_shake256 0 -314 48091 +522-33+0-151+10+8-36-62+150-123+141-23-23+105+117 xof_shake256 0 -472 64134 +109+42-62+261-140-166+439+0-60-1+52-169-150+312+553 xof_shake256 0 -709 95957 +66-368+127-111+73+37+4-277+335-248-185-317+0-259+26 xof_shake256 0 -1064 128072 +330+427+24+244-63+0-203-88-72-28-441+253+63+10-90 xof_shake256 0 -1597 191447 +363+649+147-261+396-120+203-269+421-71+123-162-54+0-48 xof_shake256 0 -2396 286829 +1709-224-241-200+623+0-519-297+1108+182+365+197+906-33-692 xof_shake256 0 -3595 429854 -162+809+1280+1049+0+567+56+369+961-1796-3859-3271-3313-4415-3264 xof_shake256 0 -5393 636532 +0-367+1604-9-181+983+616+891-522+255+850+483-202-2458-4319 xof_shake256 0 -8090 955803 -1343+147-997+22-1008-932-1579-1432-908+0+1162+2387+883+1955+1443 xof_shake256 0 -12136 1434891 +4887+757+435+963+246+917+0-117-383-765+1752-3005-12030-13902-11631 xof_shake256 0 -18205 2136602 -2354-1850+2526+2610+1352+0+273+545+664+3662-785-261-1375-3390-701 xof_shake256 0 -27308 3199707 +1192+8514+8984+7856+2558-21292-19821-21951-20379-24208-24272-24807+0+5978+6179 xof_shake256 0 -40963 4813963 -2498+1387-1403+0+2824-338+3139+3901+10814+607-1767-12635-31686-29951+5 xof_shake256 0 -61445 7188747 +14617+16320+12117+12618+17449+17913-32523-29178+14284-10844-35584-30330-30462-29741+0 xof_shake256 1 implementation tweet compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 1 0 11197 +2048+860+496+218+95+52+51-30-24+0-117-86-42-56-2 xof_shake256 1 1 11155 +174+53+29+12-58+0-51-27-51-22+31+13-11+52-79 xof_shake256 1 2 11128 +127-8-13+82+0-36+25+38-3-36-27+51+32-11+0 xof_shake256 1 4 11171 +135+120+26-38-7+13-3+6+57-15+15+0-86-18-37 xof_shake256 1 7 11152 +64+29+69-75-2+70-20+53-29+0+3-28-28+12-45 xof_shake256 1 11 11161 +206+16-19+16-63-26-37-47+38-73+0+20+27-28+92 xof_shake256 1 17 11163 +185+48+12-2+20-90+39-108+39-32-82-30+58+0-63 xof_shake256 1 26 11182 +108+12+41+9+0-23-8+26-82-61+55-61+24-30-35 xof_shake256 1 40 11167 +195+104+0+21+1-35+0+10+41-35-43-2+28-43-6 xof_shake256 1 61 11215 +193+85+70+31+27-38-15-4-53-85+0+13-82-24+0 xof_shake256 1 92 11227 +139+6+11-46-51+74+0-5+29-17+9+35-2-43-9 xof_shake256 1 139 21981 +399+187-36-23-63+53+13-11-42+52+43-52+0+7+0 xof_shake256 1 209 22018 +113+94-88-6-60-43-2-4-67+31+5+62+44+82+0 xof_shake256 1 314 32863 +193+17+35-7-72-55+143-117+27+36-69+0+63-26-14 xof_shake256 1 472 43718 +5+27+19-27+0-9-58+126+96-9-59-12+50-35+72 xof_shake256 1 709 65360 +70+105+93+2-196+0-105+25-83+190-80-8-95+83-79 xof_shake256 1 1064 87031 +60+151+61-82+21+0-68-105-36-27-21+20-54+11+14 xof_shake256 1 1597 130233 +269-153-25+231+0-87-3-79+34+78+132+199-84-65+72 xof_shake256 1 2396 195150 +275-152+288-310+27-143-49-351+43+0+524+31-20+149-91 xof_shake256 1 3595 292478 +467-250-68+130+481-304+151-344+60+176-74+172+0-251-76 xof_shake256 1 5393 432980 +17+287+255+433+303-46-17+11-28+0-57-55+874-177-15 xof_shake256 1 8090 649401 +124+69+132-86+44-202-357-60-211+84-335-333+247+0+795 xof_shake256 1 12136 973702 +613-189+438-374-166+0+18-88-198+136+1099-222+287-500+598 xof_shake256 1 18205 1449853 -284+0+900-163+587-18+168+955+527-101+393+744-605-873-271 xof_shake256 1 27308 2174990 +608+562+54-260+0-851+622+1234-802-230-335-232+1245+70-386 xof_shake256 1 40963 3267270 +876-140-1703-131-375-959-144+0-310+70+1773+433+208+595+1056 xof_shake256 1 61445 4890310 +1682-646+637+0+1516+134+1234+1574+809-1402-2275-1893-804-501-294 xof_shake256 1 -1 11125 +265-30-28+0-25-39+21+10+41+5-37+0-19+22+17 xof_shake256 1 -2 11177 +1741+359+83-2+24+8-32-38+0+47-116-25-82+23-84 xof_shake256 1 -4 11144 +174+26-54+0+33+27+1177+80-44-33-51-13+790-29-15 xof_shake256 1 -7 11127 +230+21+30+0-12-49+6-6+16+72-22-36-11+3-52 xof_shake256 1 -11 11153 +162-14+7+0+45+11-81-43+61+44-37-18-15+39-21 xof_shake256 1 -17 11157 +232-19-63-20+28+117-22+17+0+48-37-7-23+55+34 xof_shake256 1 -26 11143 +154+67+6-22-8+60-13+153+76-11+0-13-10-20+7 xof_shake256 1 -40 11183 +110+31-23+52-30-9-13+46-5+0-32-18+5+12+15 xof_shake256 1 -61 11202 +76+5+82-45-66+15-1-40+0-17+118-35-55+49+16 xof_shake256 1 -92 11253 +100+44+18+34+0+5-28+593+29-26-61-34-5-36-16 xof_shake256 1 -139 22190 +253+59+24-33+139-76-20-38-9-101-39+43+103+0+2 xof_shake256 1 -209 22263 +69-30+14-29+38-21+167-14-78+56+22-12+0+2-55 xof_shake256 1 -314 33311 +187-5-64-34-8+0+982+712+679+90-30-11+58-21+50 xof_shake256 1 -472 44398 +112+37+11+20-70+64-48+42-100+0-103+11-122-43-110 xof_shake256 1 -709 66449 +2+12+12-69-16+86+5-220-76+89-90+32-105+0-132 xof_shake256 1 -1064 88696 +908-20-56-205-64+871+195+1058+60-81-204+0-81+836+601 xof_shake256 1 -1597 132913 +221+3-32+119+1144+0+50+138+1071-80-210-372-34-296-89 xof_shake256 1 -2396 199137 +200-84-58-221-206+913+725-315-34+615+727-140+0+933+550 xof_shake256 1 -3595 299138 +181-127+93-93-873+367+238+0+32-748+1130-735+1529-905-317 xof_shake256 1 -5393 442724 -598+663+1133-682+549-140+0+729-147+456-140+902-824+1098-310 xof_shake256 1 -8090 664171 +678-498+568-273+95+266-23-668+3-247+68-258-1565+0+563 xof_shake256 1 -12136 994377 +1767+3361+2368-120-226-326+267-107-84+0-11+426+428+981-81 xof_shake256 1 -18205 1480045 +26+621+95+77+812-275-31-487-745-11-1070+0-349+951+7 xof_shake256 1 -27308 2220685 +442+0+83+657+406-151-271+77+65-18-694-506+534-316-827 xof_shake256 1 -40963 3335183 +789+601+40-128-664+0-195+855-805-254-82+715-605+41+584 xof_shake256 1 -61445 4992486 +541-336-1079+619-152+731+1333+2211+1174+3067-218-221+0-1584-742 xof_shake256 2 implementation tweet compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 2 0 16503 +5394+1493+1161+317+0-68-12-95-117-16-5-1+2+138+76 xof_shake256 2 1 16449 +356+65+1004+206-5-36-53+14-19-55-56-74+0+7+19 xof_shake256 2 2 16543 +1389+287+191+185+101-40+0+30-50+49-6-99-60-55-4 xof_shake256 2 4 16531 +278+157-53+9+13+0-49+50-56+23-48-73+52-58-41 xof_shake256 2 7 16507 +401+196+114-4+24+1-11-33-23+29-32-12-42+146+0 xof_shake256 2 11 16505 +166-42+137+42-13+155+1164+95-26+56-20-24-7+0-8 xof_shake256 2 17 16507 +141+0+20-20-31+10-51+22-64-4-77+75+40-12+22 xof_shake256 2 26 16537 +371+166-23+0-43+15+68+62+37+27-9-10-24-4-15 xof_shake256 2 40 16549 +292-45+65-72-27+0+23+37-73+1-100+36-5+30-54 xof_shake256 2 61 16560 +325+0+21+12-4-3+31+159-51+45-26+71-50-32-41 xof_shake256 2 92 16614 +338+78-157-31-66+0-69-82+8+83+96-9+44+13-97 xof_shake256 2 139 32398 +315+140+45-69+61+82+122+70-34-136-120-71+0-89-25 xof_shake256 2 209 32427 +928+990+423+288+104+0-42+1048+33-310-249-307-107-241-241 xof_shake256 2 314 48603 +108-153+36-70+105-44+50-106+103+17+0-69-8+416-525 xof_shake256 2 472 64556 +871+677-35+54+48+288-710-882+1092+0-15+11-131-228-61 xof_shake256 2 709 96094 +199-19-4-369+246-1+0-36-119-202+182+200+1523+97+213 xof_shake256 2 1064 128186 +188+58-47+807-24+0+111-64+122+30-25-84-129+30-113 xof_shake256 2 1597 191889 +216+37-98-345-208+81+1309+142-176+0-103+840+737-84-55 xof_shake256 2 2396 287711 -136-276+752-87+0+144-50+174-41+151-414+0+50+569-806 xof_shake256 2 3595 432125 +4469-1593-2319-1832-2467+3106+2278-3796-2234+403+3839+495+727+0-100 xof_shake256 2 5393 641210 -1292+0-2559+1312-1307-1253-759+1349+2525+6356+8260-1023+412+489-266 xof_shake256 2 8090 958620 +1008-8341-964+2515+2195+0-1357-3118+1322+2501+1036-21-24-156+1146 xof_shake256 2 12136 1436334 +1367+965+5038-5297-3946-981+814+0+9069-331+7295+783-6000-8736-4623 xof_shake256 2 18205 2140550 +0-3651-7967+1323-14558+2550+3944+2453-19448-6868-5418+5759-5490+5488+8302 xof_shake256 2 27308 3211585 -5421+10594+0+7448+9010-4663+3110+5073+7420-14173+10120-1861-12393-20736-3446 xof_shake256 2 40963 4810216 -12262-368-5077+8664+18835+9114+10274+13373+0-5344+8888+1359-327-4465-1477 xof_shake256 2 61445 7203219 -11518-15539-3212-13171-8817-32144+13808+33415+16650-13746+0+4936+40525+34662+23922 xof_shake256 2 -1 16590 +179-83+40-43+75+4-49-85+74+0-100-24+109-70+6 xof_shake256 2 -2 16567 +416-129-132-46+2+11+672-30+0-12+61-139-26+17+14 xof_shake256 2 -4 16580 +107+50+0+38+13-9-83-11-10+92+17+5-67-65-45 xof_shake256 2 -7 16611 +195+30+0-65-33-27-49-82-55-52+36+40+95+56+4 xof_shake256 2 -11 16563 +254+84+56+124+3-13+37+96-103-11-13-15-38+0-37 xof_shake256 2 -17 16588 +239-33-125+81+122+73+153+41+67-111-48-101+0-76-19 xof_shake256 2 -26 16583 +168+22-15+122-136-7-129+0-48+88+76+76-26+21-57 xof_shake256 2 -40 16603 +386+286+49-87-26+38-16-13+33-16+0+76-23+137-58 xof_shake256 2 -61 16673 +116-18-1+28-39-42-55+26+0+12-26+28+19+44-32 xof_shake256 2 -92 16672 +289+154-16-117-55+39+50-28-16-51+34+0+80-90+21 xof_shake256 2 -139 32683 +311+143-9-107+34-70+80+0-59-101-25+112+89+99-66 xof_shake256 2 -209 32861 +159+233-90+680-117-87-20-246-112+38+102-119+52+0+70 xof_shake256 2 -314 48752 +511+28+10-167+263-326-185-22+0-84+300-95+42-196+4 xof_shake256 2 -472 64696 +109+116+44+77-156+60-34-29-44+141-126+0+206-154-212 xof_shake256 2 -709 96538 -168-891+158-13-43+238-81+0+301+14+475-52-73+26+235 xof_shake256 2 -1064 128850 +824+520-248+89+393+508-231-487+0-170-132-69-185+49+251 xof_shake256 2 -1597 193145 +1009+232+729+322+0+121-190+210+1378-351-1431-2072-2486-2368-2076 xof_shake256 2 -2396 289816 -557-450+3+1-754-708+323+1615+0-142+372+250-674+852-377 xof_shake256 2 -3595 434372 -594-1371+623+0+472+171+40-1009-358+62+79-449-479-1152+869 xof_shake256 2 -5393 642753 -211-543+714-695+1888+1526-242+6780+10491+2169-673+0-317-1869+1019 xof_shake256 2 -8090 964752 -4629+7124+3010-2393-3163+2723+668-328-277-44+0+50-758+2527+1540 xof_shake256 2 -12136 1441897 +9274+5365+12584-3449-13788+12426-8211-10235+10688+0+14464+10766-7903-124-4903 xof_shake256 2 -18205 2156219 +5685-12404+1672-77+4487-19476+0+1769-18650-17265+5945+8639+12336-926-1107 xof_shake256 2 -27308 3222905 +8793+16905-23344+2410-2911+13766+32304+11603+0-2491-10577-5467+419-7900-6505 xof_shake256 2 -40963 4833140 -9004-9806+13280+22246-16752+2470+9808+30982+3250-4831-19636-10659+7852-37008+0 xof_shake256 2 -61445 7235541 +0-4472-547+20261-23018-7988-43994-83379+2238+8158+7785-7644+27942+42487+32796 xof_shake256 3 implementation tweet compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 3 0 11136 +3895+1157+425+173+12+7-54-71+27+0-144-47-76-90-71 xof_shake256 3 1 11077 +268+14-60+15-53+54+13-58+0-5-24+1+78-2-49 xof_shake256 3 2 11080 +53+1+15+32-106-34+47+6-32+0-30-44-85+30-44 xof_shake256 3 4 11042 +52+67-23+50+0+8-25+41+25-5-33+92-13-3-51 xof_shake256 3 7 11062 +93+49-20+0-15+45-25-33+74+11-70-33+60-15+31 xof_shake256 3 11 11075 +51+52-21+37-34-7+79-58+14+39-24+0+0-11+0 xof_shake256 3 17 11081 +117+69-25-13+59+0-36+27-16-2-73+3-41+15+30 xof_shake256 3 26 11082 +134+147+0-8-43+29-55-14+26+8-71-19+22+65-40 xof_shake256 3 40 11078 +84+74-13+13+0-66+0-23-1-25+13-27-69+41+29 xof_shake256 3 61 11093 +63+13-42+50-82+59-127+6+0-43-43+23-2+22-76 xof_shake256 3 92 11072 +108+0-11+42-9-15+1-19+16+55-35-2-84+24+38 xof_shake256 3 139 21790 +212+198-4+0-19+16-17-12+52+38+21-60+49-26-31 xof_shake256 3 209 21762 +200+92+53-47+26-10+10-66-8+0-36-2-45+47+36 xof_shake256 3 314 32529 +176+54+0-13-32+0-19-30+21+20+79-46-62+9+98 xof_shake256 3 472 43231 +31-16-3+84+0+114-14-8+21+79+73-70+3-3-13 xof_shake256 3 709 64721 +109+146-142-31-72+188-29+49-77+41-36-29+0+40+23 xof_shake256 3 1064 86181 +258-87+49+49-16-102+32-40-52-56+0-18+13+68+28 xof_shake256 3 1597 129097 +124+65+78-87-144+0-201+33+821-124+42-72+59-233-90 xof_shake256 3 2396 193474 +455+262-116+47+141+158-59+0-95-143-155+44-46+17-3 xof_shake256 3 3595 289937 +179+20+79+166-132-119+18+0+156-78+27-28-2-111-2 xof_shake256 3 5393 429349 +254+240+237-68+799+167-25-24+212-108+140+0-148-118-135 xof_shake256 3 8090 643890 +236+0+129-48-86+199-231+31+33+529-154-315-118-680+714 xof_shake256 3 12136 966343 +590+51+636-347-91-65+1575-226+75-473+381-231-230+841+0 xof_shake256 3 18205 1439279 +1218+869+0+118+461+1108-14+1061+990-739-525-993-1199-2086-2655 xof_shake256 3 27308 2156597 +1271-121-1522-1255-247-500-721-931+3553+2517+2341+2746+1463+859+0 xof_shake256 3 40963 3241643 -731+951+2109-651-150-171+826+328+1799+2467+0-1214-1291+193-678 xof_shake256 3 61445 4851302 -1123-1281+2184+4773+2495+377+857-1215-604+0-3513-505+1387+2460-531 xof_shake256 3 -1 10996 +239+99-40+23-42-15+51+703-15+3-67+17-57+0-17 xof_shake256 3 -2 10982 +91+6-21+0-7-36-12+8+23-35+62-26+12-9+105 xof_shake256 3 -4 10997 +40-30-29+67-29+0+58-87+48-61+49-38+6-17+2 xof_shake256 3 -7 10992 +6+37-44+37-58-39+62+51+19-37+3-22+0-29-19 xof_shake256 3 -11 11002 +261+837-31-11+0+29-12+26-40+84+36-34-60+48-34 xof_shake256 3 -17 11026 +102+145+40+76-30-9-1+13-24-2+68+33-70+0-42 xof_shake256 3 -26 11041 +21+0+743+46+49-30-10-3-56+22-42+30-48-3+21 xof_shake256 3 -40 11070 +82+48+53-14+0+13-12+11+34-25-16+11-15-4-102 xof_shake256 3 -61 11092 +59+36+19-6-38+12-5-29+35-31+0+6+0-16-24 xof_shake256 3 -92 11175 +65+166+6+21-20+0+38-45-21+4-5-35-81+25-32 xof_shake256 3 -139 22151 +76+0-49-46-53+12+18-8+71+647+95-36-50+725-72 xof_shake256 3 -209 22259 +11+0+30+58-13+38-40-9+14-68-30-57+28+20-101 xof_shake256 3 -314 33413 -46-81+39-116+13-24-13+2+19+0-31+752+16-42+591 xof_shake256 3 -472 44491 +169+170-33+60-42-41+82+145+0-13-71-22-34+16+65 xof_shake256 3 -709 66783 -29+46+0-13-120+23-61+98+7-5+157-17+683+788-116 xof_shake256 3 -1064 89200 -24-151-74-29+639+5+652-29+65+0-20+5-105+114+528 xof_shake256 3 -1597 133813 -82+26-268+483-92+774-82-141+47-171+707+16+485-65+0 xof_shake256 3 -2396 200681 +0+527-20+621-179+473-84+447-176-211+557+610+194-257-155 xof_shake256 3 -3595 300764 +163+1619-12-5+636-182-54+733+127-61+424-332+0+697-389 xof_shake256 3 -5393 445533 +0-181-39+367-69-51+78-81-266+75+12+4+670+707-274 xof_shake256 3 -8090 669146 -123+448-647+364-245+439-209-720+473+577+788-655+0-13+568 xof_shake256 3 -12136 1002904 +49+0-617-941+43-1202-553-1234-917+460+460+291-41+359+682 xof_shake256 3 -18205 1493648 +1252+444+389+243-825-1251-1292-216-1032-491+0-66+1138+267+1137 xof_shake256 3 -27308 2239941 +1294-863-372-1456-16+1189+2243+1410+2010+2733+940+0-1105-1834-1625 xof_shake256 3 -40963 3366646 +1456+1048-1043-1307-3059+534+1648+1898-2114-2592-3936-1241+2125+0+1628 xof_shake256 3 -61445 5038384 -1989+3106+570-1457-4628+1681+3407-1752-2278-2506+2826+4303+0-3655+166 xof_shake256 4 implementation unrollround compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 4 0 1982 +12659+115+51+31+7-2+0-2+5-1+0-2-5-1-5 xof_shake256 4 1 1981 +53-2+18+10+0-3-2+5+0-2+2-5+0-5+7 xof_shake256 4 2 1982 +111+49+2+9+0+0-2+7-1-4-1+0-2-2+5 xof_shake256 4 4 1982 +108+36+14+0-1-1+3+2-3+0-4-2-2+6-4 xof_shake256 4 7 1981 +36-8+4+9-2+0-3+7-2+0-2+0-2-1+6 xof_shake256 4 11 1979 +109+17+13+1-2-1+8+0+21+0-2-1-2+8+0 xof_shake256 4 17 1980 +108+35+8+0-5-2+7-1+1-1-2-1-3+18+8 xof_shake256 4 26 1977 +110+21+16+7+2-1+9-2-1+0+0+0-1+8-1 xof_shake256 4 40 1981 +109-47+9+0+4-2+0+0+18+3-3+5-1-2-2 xof_shake256 4 61 1981 +30+3+8+7+0-1-1+3-2+0-3-1-2-1+5 xof_shake256 4 92 1984 +140+1+29-5+5+0-1+0+8+0-1+0-2-3+1 xof_shake256 4 139 3520 +361+112+64-5-3-5-1+2+0-4-7+0+1+0+3 xof_shake256 4 209 3545 +130+17-6-10+2-11-12+1-9-5+16+0+8-3+5 xof_shake256 4 314 5131 +199+114+40+49+36+44+48-6-11-4-12-6+0-7-12 xof_shake256 4 472 6631 +173+33+39+11-21+8-6-11+14-8+0+0-1+5-8 xof_shake256 4 709 9685 +354+202+14-4+26-12-18+13+45-8-8+0+5-4-9 xof_shake256 4 1064 12919 +249+80-10-17+6+22+19-3+46-1-11+16-21-6+0 xof_shake256 4 1597 19104 +739+41-32+22-34+4+6-24-37-34-6+5+0+33-25 xof_shake256 4 2396 28322 +162+26-46-2-19+0-12-30+0+41+44-6-2+1171+117 xof_shake256 4 3595 42106 +180+25+0-27+5-17-79-2-3+46+849+28-9-5+797 xof_shake256 4 5393 62125 +226+32+918+725+0-13-2-44+22-101-9-63+21-29+21 xof_shake256 4 8090 92909 +1049+770-53-39-64+0-84-50-14+870+327+365+950+23-72 xof_shake256 4 12136 138952 +225+1021+28-56+743-100-87-43+1317+0+765-7-109-76+901 xof_shake256 4 18205 206466 +330+0-66+694+115-12-68-24+905+40+40+44-39-41-24 xof_shake256 4 27308 309405 +477-7+41-141-44-36+28-74-66-33+1018+0+127+1044+179 xof_shake256 4 40963 465643 +89+2132-826+702-908+662-910+788-58-38-98+0-209+155+100 xof_shake256 4 61445 696358 -587+48-935+23-924+0-218-102-23+504+714+1150-142+1007+1290 xof_shake256 4 -1 1795 +333+130+4+9-3-6+0-1-2+0+4-4-1-2+6 xof_shake256 4 -2 1801 +172+121+31+11+1-3-7+1-1-2-4-6+0-2+3 xof_shake256 4 -4 1814 +152+110+3+3+0-5-5+5+1-5-4-1-4-1+4 xof_shake256 4 -7 1831 +174+268+16+11+2-2+5+0-4-2-3-1-3+5-1 xof_shake256 4 -11 1855 +255+185+6-1+3-1+4-3-3+1+0-4+0+9+0 xof_shake256 4 -17 1890 +123+68+22+7+0-3+0+8+2-1+0-2-1-3+7 xof_shake256 4 -26 1944 +86+245+39+9+0+0-2+8-1-2-1+0-1+2+7 xof_shake256 4 -40 2029 +97+68+48+35-1-3-3+5-2+1-3-2-1+0+5 xof_shake256 4 -61 2156 +86+54+26+3-1-2-3+3-1-4-4-1+1+0+8 xof_shake256 4 -92 2343 +99+12+32+27-9-6-5+4-1-4+1+0-3-3+6 xof_shake256 4 -139 3470 +359+23+45+2-5-6-3+0-8+0-5+5-7+4-5 xof_shake256 4 -209 3904 +183+3+3-16-1-18+21-5+3-11+8-16+3-4+0 xof_shake256 4 -314 5492 +82+59+100+15-13-9+0+14-6-9-10-7+16+2-12 xof_shake256 4 -472 7297 +42+57+20+0+8-6+8-6-3+4-9-11+2-8-4 xof_shake256 4 -709 10398 +36+44+22+20-3-1+0-1-3+5-5+4+8-3+0 xof_shake256 4 -1064 14281 +83+110+57+34-24-31-6-9+18-8+7+1-2-4+0 xof_shake256 4 -1597 20875 +49-11+18-27+11+5+0+8+18-2+0-5+21-1-1 xof_shake256 4 -2396 30738 +77+1-24-2-2-1+836+46+7+5-1+3-7-7+0 xof_shake256 4 -3595 45531 +40+33-1-7+2-1+0+948-55-9-11+739+54+49-43 xof_shake256 4 -5393 67329 +41+77-25+31-10-83+0-12-89+13-79+7+768+65-46 xof_shake256 4 -8090 100377 +108+18+6-16-2+0+836+15+1+0+10-17-3-10-4 xof_shake256 4 -12136 150003 +442+38-32-40-45-13-17-46+819+44+38+10+0-33+736 xof_shake256 4 -18205 223635 +171+31+22-38+839+0-79-84-90+781+17-34-31+1384-41 xof_shake256 4 -27308 335727 +551-766-102+0-768+662+92-81+248-746-16+68+2-852+45 xof_shake256 4 -40963 502099 +299+914+83-107+25-56-85-5+931-67+0+96-117-40+655 xof_shake256 4 -61445 752865 +770+400+0+610+694+572+754-267+538-254-957-109-924-1168-905 xof_shake256 5 implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 5 0 1681 +2218+158+64+43+12-8-10-9+26+12+0-3-7-8-9 xof_shake256 5 1 1677 +207+56+27-2-3-5-5+0+14-2+0-7+1+20+23 xof_shake256 5 2 1703 +107+52-26-1+0+0+0+1+26+44+1-2-4-1+656 xof_shake256 5 4 1680 +117+49+76+2-10+7+3-10+12-10-1+0+0-1-10 xof_shake256 5 7 1677 +66+26+1+1-7-6+9-6+17-7+2-7-8+0-4 xof_shake256 5 11 1700 +147+34-3-7-5+0+6-4+13+2-6+5-8+3-7 xof_shake256 5 17 1713 +175+55-3-4-1+5+6+0+17+2+1-29-29-29-27 xof_shake256 5 26 1715 +71-15+28+22-3+3-1+0+78+3+57+0-2-3-3 xof_shake256 5 40 1699 +168+67-3-21-9+14+0-4+21+4+0-2+2-1-1 xof_shake256 5 61 1667 +141+63-1-4+3-2-4+12+24+16-3-2+0+6-2 xof_shake256 5 92 1696 +279+81-33-7+0-2-4-3+18+0+0-3+2+8+6 xof_shake256 5 139 3150 +428+36+0+1+0+7+5-7+12-2-8-2-3-5-5 xof_shake256 5 209 3118 +151+13-9+9+0-2+3-7-4-4-6+7-6+17+15 xof_shake256 5 314 4549 +254+82-13+0-10+0-13-11-11-11-18+871+54+28+19 xof_shake256 5 472 5974 +142+62+4+45+22-4-6-15-12+2-10+2-11+0-9 xof_shake256 5 709 8877 +198+9+796-21-8-10-21+1+25-22+7-27+8+0-18 xof_shake256 5 1064 11715 +250+29-1+13-8-15+0+50-24+0+46-22-6-3+5 xof_shake256 5 1597 17406 +123+32-22-5+63-14-6+0+22+28-2-1-1+10+22 xof_shake256 5 2396 26012 +127-12-12-2+23+58-14+0+12+12-36+29-2+33-2 xof_shake256 5 3595 38916 +151-30+41+2-8-32-11+25+0+4-4+4-4+4-4 xof_shake256 5 5393 57418 +308-16-17-9-15+72-14+0-1+814+61+128+101+10-20 xof_shake256 5 8090 86019 +361+0-30+12-1+45+15+12-4-12-27-2-26+1+52 xof_shake256 5 12136 128865 +287-43+0+80+77-50-24-1+165+158-5+791+205+0-1 xof_shake256 5 18205 191789 +339-124+969+48-201-124-101+0+789+126-34-113-224+860+985 xof_shake256 5 27308 288401 -315+432-748+65+344-870-267+231-915+0+293-551+143+334-684 xof_shake256 5 40963 432352 +357+884+138-157-152+54+0-209+705+15-156-143-151+172-8 xof_shake256 5 61445 647807 -383-188+183-721+827-116+746-524+1648+851+0+843+200-242-124 xof_shake256 5 -1 1507 +245+114+0+0+0+2-2+0+6+0+0-2+0+5+0 xof_shake256 5 -2 1511 +138+49+26+2-2+0-2-1+6+0+5+0+0+0+0 xof_shake256 5 -4 1521 +149+81+40-4+0-2-4+0+10+7-4-3-2+8-2 xof_shake256 5 -7 1531 +147+74+4+0+0-2+0-1+5-1+0-1-2-1+1 xof_shake256 5 -11 1547 +117+49+1+0+0+0+6-2+13+1-1-2-1+8-2 xof_shake256 5 -17 1576 +114+38-2+6-6-3-4+2+4-4-1+18+1-1+0 xof_shake256 5 -26 1624 +113+43+16+1-2+0-4-5+0-10-4+0+16-1+2 xof_shake256 5 -40 1693 +131+50+40-5-3+1-6-1+0+5-4+12-3+9-3 xof_shake256 5 -61 1795 +109+51+27+22-3-2+0+0+10-2-1-1+5-2-4 xof_shake256 5 -92 1953 +134+45+23+0+10-5-7-3+8+5-6-3+1-5-7 xof_shake256 5 -139 3071 +305+146+20+23-6-5-1-3+0-5-6+1+10+4-2 xof_shake256 5 -209 3413 +122+44+5-3-1-3+3+0+5-4+0+0-5+1+3 xof_shake256 5 -314 4859 +101+52+8-5-10-5-8+4+0-6-6+4-13+1+31 xof_shake256 5 -472 6676 -24+49+17-11+2+10+0+0-9-6+24-2+11-3+52 xof_shake256 5 -709 9591 -18+20-5-3+5+9+30-9-8+2+0-8+2+12-2 xof_shake256 5 -1064 13249 -89+42+19+8-7+15-5-7+0-7+1+10-14-23+12 xof_shake256 5 -1597 19321 -22-2+8+20+25-9+10+0+18-30+75-24+0+54-2 xof_shake256 5 -2396 28568 +7-28+7+15-3+0+42+33-15-7-18-11+14+9-18 xof_shake256 5 -3595 42440 +20+50-1-14-12+0+5+29-23-23-2-8+43+5+2 xof_shake256 5 -5393 62911 -61-24-64-31+909+21+87+0+3-4+23-34+11-36+59 xof_shake256 5 -8090 93905 -8-43+138-66-38+20+2+0+7-37+943-93-16+54+3 xof_shake256 5 -12136 140385 -43-32+917-74+16-9+906-68+36+26+834-4-36+0+1060 xof_shake256 5 -18205 209385 -88+877-87+573-64+696-276+914-42+1140-22+0+956+805-112 xof_shake256 5 -27308 313634 +989-142+1632-2+123+52+113+0-87+156-24+7-178-92-11 xof_shake256 5 -40963 471370 -863-907-850-655+730-990+58+158+616-1014+212+0+879-922+772 xof_shake256 5 -61445 704538 +1936+1790+954-174+815+634-75+117+774-275+0-105-37-241-167 xof_shake256 6 implementation unrollround compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 6 0 2439 +2819+145-36+17-8+38+46+1-9-9-8+1-2+0-8 xof_shake256 6 1 2436 +161+104-13-4+4+1+5+2-2-1+3+0+0-1+0 xof_shake256 6 2 2437 +124-4-57-2+3-3+0+1+2+0+0-1+3+0+0 xof_shake256 6 4 2437 +82+69-2-2+2-3-2+9-6+0+6+1-7+2-8 xof_shake256 6 7 2433 +818+105+38-55+3+0+2-4-3-6-6+3-7+0-1 xof_shake256 6 11 2434 +80+69-9-6+14+7-3+0-1+6-3-3-3+0+4 xof_shake256 6 17 2432 +136-51-43+2-1+0+1+1+3+0-3-6-3+0-2 xof_shake256 6 26 2428 +100+56+6+11+9+9-2+0-1-3+0-4+0+0-4 xof_shake256 6 40 2422 +162+36-28-1+16+1-1+6-1+6-2-2+0+6-2 xof_shake256 6 61 2428 +105-46-52+0+9+0-1-2-3+1-3+0+1+4+0 xof_shake256 6 92 2438 +204+4-46+1+2-2-3+4-3-1-3+7+0+3-7 xof_shake256 6 139 4552 +403+65+29+18+2-7-3+48-1+0+0-4+4-4-4 xof_shake256 6 209 4555 +154-27-52-7-1+3+44-2+4+0+0+8-1+6-2 xof_shake256 6 314 6733 +211+34-34-4-8+4+8+42+0+0+7-1+38-21-22 xof_shake256 6 472 8960 +230+92-28+0+5+9+4+45+18-21-64-54-66-55-74 xof_shake256 6 709 12982 +368+229+0+58+14+1-35-42+29-49-46+12-44-41-63 xof_shake256 6 1064 17333 +326+204+146+80+0-19+30-45-35-2-37-16-47+1+1 xof_shake256 6 1597 25744 +352+234+63-2-55-10+14+30-46+31+0-27+48-10-22 xof_shake256 6 2396 38362 +318+63+32+30+20+4-48+50-15-10-33+0-29-27-23 xof_shake256 6 3595 57274 +79-68-47+0+29+39-6+1+27-3-47+641+323-101-9 xof_shake256 6 5393 84560 +119+36-9+15-3-19-121+40-4+0+76+43-33+24-32 xof_shake256 6 8090 126788 +154+0+14-14-5-5-5-53+46-10+40+8+26+39-11 xof_shake256 6 12136 189531 +127+593+52+27-16-34+767+727-27-60-1+1876+0-22-87 xof_shake256 6 18205 282567 +0-635+744-749-665+386-706-629+171+113-617+131+79-629+115 xof_shake256 6 27308 422658 +1546+138-67-6+0+24+14+32-16+27-49+721-33-120-159 xof_shake256 6 40963 636023 +984-203+446+603-515-454-7+0-1288+181+277+363-1247-14+183 xof_shake256 6 61445 950926 +376-821-996-1065-961-1188+0+1517+233+303+941+767+392-207-235 xof_shake256 6 -1 2216 +330+145+7+3+5-2+1-2-2-4+0-1-2+1-1 xof_shake256 6 -2 2224 +182+67+23+3-1+0+2-3+3-1-3+5-3+0-2 xof_shake256 6 -4 2236 +227+29+11+10+4-6-4-4-1-2-3+4-1+0+0 xof_shake256 6 -7 2260 +204+79+24-8-10-3-2+753+18-13-1+0+0+723+75 xof_shake256 6 -11 2293 +155+119+48+8-2-1+0-3-4+1+5+3+0-7-6 xof_shake256 6 -17 2321 +217+94+65-17-21-21-29-20-26+17+0+22+0+29-4 xof_shake256 6 -26 2398 +166+113+33+2+3-4-2+0-4+2-4-1-5-2+44 xof_shake256 6 -40 2470 +119+125+52+1+0+8-2+9-2+0-1+5-3-5-5 xof_shake256 6 -61 2577 +160+95+40-5+3+6-1-5-6+2+0+0-6-6-2 xof_shake256 6 -92 2736 +174+70+73-12+1-5-4+2-6-6+0+0-9-12+41 xof_shake256 6 -139 4441 +371+70+92+17+1-5-4+37-2-6+2-2+0-5+0 xof_shake256 6 -209 4798 +209+106+35+79+43+10-1-10+39-9-5-10+0-13-10 xof_shake256 6 -314 6965 +115+111+58+4-10-5+39+0-3+8-8+0-4+43+0 xof_shake256 6 -472 9292 +138+137+78+46+51-9-12-9+27-10-14+43-8-7+0 xof_shake256 6 -709 13515 +165+93+41-13+37-9-9+58+0+31-9-3+30-11-13 xof_shake256 6 -1064 18420 +144+97+247-28+0-46+3-62+32-51+4-20+8-22-39 xof_shake256 6 -1597 27199 +677-25+14-35-6+16-11-45+0+4-43+2-45+8+4 xof_shake256 6 -2396 40330 +54+823+40-7-45-9-29-19+730+773+23+8-24-15+0 xof_shake256 6 -3595 60045 +51+104-22-8+2+150-49-52-45+5+0-48-83+743+73 xof_shake256 6 -5393 88857 +829+95+132-10+5+0+0-8-17-10+1-8+19-10-8 xof_shake256 6 -8090 132852 +119+0-35+925+274-16+60-40+13-7+48-61-40-15+12 xof_shake256 6 -12136 198814 +116+39-9-40+65-2+43-49+0-29-10-26+869+72+13 xof_shake256 6 -18205 297046 +95+153-599-740+651-620-3+125-769+0+73-662+67+8-691 xof_shake256 6 -27308 444154 +764+860+823+792+616-53+1973-33+576+0-52-22-76-21-177 xof_shake256 6 -40963 667130 -651-1038+73-634-70+1400-5-218+798+427+75-152+815+878+0 xof_shake256 6 -61445 998639 -779-438-833-830-101-1474+18+0-538+1253+494+623+485+535+1334 xof_shake256 7 implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 7 0 1928 +2944+168+72+35+0+0+0+0+21+0+0+0+0+0+0 xof_shake256 7 1 1931 +238+70+63+0+0+3+1+0+23+0+0+0+0+0+0 xof_shake256 7 2 1932 +173+106+46+0+0+1+0+0+22+5+0+0+0+0+0 xof_shake256 7 4 1932 +143+102+40+0+0+0+0+0+22+0+0+0+793+73-1 xof_shake256 7 7 1932 +148+7+0+1+0+0+0+0+22+2+0+0+2+0+0 xof_shake256 7 11 1924 +174+93+0+0+0+0+0+0+23+0+0+0+0+0+0 xof_shake256 7 17 1925 +130+49+0+0+0+1+0+0+22+1+0+2+0+0+21 xof_shake256 7 26 1923 +76+33+0+0+6+0+0+0+21+0+1+0+1+0+0 xof_shake256 7 40 1919 +161+93+2+0+4+0+0+0+21+0+1+0+0+1+0 xof_shake256 7 61 1921 +62+29+1+0+0+0+0+0+21+0+0+0+4+2+0 xof_shake256 7 92 1931 +246+106+39+1-5-4+6+0+13-5+0-2-1-5-2 xof_shake256 7 139 3632 +378+133+1-3-2+0+1-3+8+0+3-2-4-5-4 xof_shake256 7 209 3629 +240+39+1-2+4-5-3+1+2-4+0-5+4-2-4 xof_shake256 7 314 5472 +127-42+0+1+0-4-6+1+13-1-1+4-2-2+0 xof_shake256 7 472 7169 +40+10+1+13+5-2-4+0+7-1-4+0+2+0-7 xof_shake256 7 709 10614 +227-6+23-7+3-6-1-8+9+5-3-6+4+0+2 xof_shake256 7 1064 14106 +156+0-105-115+52-101+97-105+109-110+83-101+82-114+88 xof_shake256 7 1597 20855 +281-10-59-3+104+105+182-55+140-52+761+13-22+0-50 xof_shake256 7 2396 31210 +973-199+0-27+8+16-2+25-144+28-159+26-156+27-142 xof_shake256 7 3595 46374 +184-14+845+4-11+164-4+726+21-29-5-14+914-18+0 xof_shake256 7 5393 68636 +1015-90-157-155-154+22-17+788-107-129+2+11+1+0+640 xof_shake256 7 8090 102528 +492+816-17-21-69-52+117+78+647+921+0-17-36-94+117 xof_shake256 7 12136 153605 +664-81-121+807+613+314-113-120+735+0-166+931-132-132+693 xof_shake256 7 18205 228358 +845+893+267-29-61+0+965+117-11-20-26-37-39+1250+329 xof_shake256 7 27308 342917 +509-440-438-402-488-488+1030+0-404+773+242-443+1226+823+1018 xof_shake256 7 40963 516383 -140+842+259-657+884+0+149+79+65+168-104-789-722-817-584 xof_shake256 7 61445 773118 -1080+118+172+31-206-352-572+835+27+0+186-22+225-574-608 xof_shake256 7 -1 1779 +365+102+23+20+3+0+0+0+21+0+3+0+0+0+0 xof_shake256 7 -2 1784 +207+69+0+0+0+0+0+0+21+0+0+0+0+2+0 xof_shake256 7 -4 1793 +157+77+0+0+0+0+0+0+21+0+0+0+0+0+0 xof_shake256 7 -7 1809 +116+49+1+0+1-3+0-3+18-3+0-3-3-3-3 xof_shake256 7 -11 1824 +133+28+0+0+0+0+0+0+21+0+0+0+0+0+0 xof_shake256 7 -17 1851 +115+80+0+0+0+0+0+0+21+0+0+1+0+0+0 xof_shake256 7 -26 1894 +112+79+20-2-2+2-2+1+19-2-2-2+0-2+0 xof_shake256 7 -40 1958 +151+53+14+13+15+3-3+0+18-3+0-1-3-1-1 xof_shake256 7 -61 2058 +120+58+10-9-9-1-6+7+14-9+4-2+0-5+0 xof_shake256 7 -92 2204 +104+51+29-8-15-15+20-3+8+0+8+10-2-10+0 xof_shake256 7 -139 3780 +328+179+85+76+36-2+0-1+19-2-2-2+1+0-2 xof_shake256 7 -209 4113 +180+38+24+22+12+0-9-7+8+25-15-1-12-12-5 xof_shake256 7 -314 6105 +56+118+49-4+3+2+4-3+2-2+0-5-7-9-1 xof_shake256 7 -472 8221 +25+61+28+4-6+2-6+0-8+1+10-5+0-4-5 xof_shake256 7 -709 12045 +39+35+27-3+1-5-2+2+8-3-1+0+2-1-4 xof_shake256 7 -1064 16461 +28+68+68-25+9-5+0-20+7-14+30+9-17-23-1 xof_shake256 7 -1597 24390 -23+21-22+12-29+24-3+0-16+17+9-26+13-28+11 xof_shake256 7 -2396 36266 -25+19-10+12-14+1-10+6+3-22+1+0-1+6-15 xof_shake256 7 -3595 54086 -20+24-16+12-15-4-16+11-19+0+7-6+870+24+16 xof_shake256 7 -5393 80142 +50+66+27+795-16-12+0-15-7-6+53-22-1+0+33 xof_shake256 7 -8090 119936 +80+31-1+2+7-18-6-32-13+4-8+7-15+4+0 xof_shake256 7 -12136 179616 +4-20+817+0-16-13+786+848+10-3-30+737+952-196-39 xof_shake256 7 -18205 268543 +138+47-758+136-994+35+139+427-844-830-31+0-792+624-838 xof_shake256 7 -27308 401456 +1660-245+764-24+805+0-28+708+6-77-51-70-75+754+13 xof_shake256 7 -40963 603286 +86-5+0+651+97-286+679-69-102-43-841+752+1452-843+613 xof_shake256 7 -61445 902859 +67+0-871-35-822-875-888-47-14+687+685+52+690+593+607 kem_6960119 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair selected 1047319 362466839 +240916526+119525471-120040502+541832-60404283+298838230-179395514-179712637-179789687+179370732+0+81368-59913669-119856940+127000721 kem_6960119_enc selected 194 131734 +15089+10186+2856-2731+16779-374+6999-190+2224+4286+0-3421-716-900-1150 kem_6960119_dec selected 194 269177 +19256+2879+1816+632-121+255-130+0+522+243-97-50-186-342-515 kem_6960119 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119_keypair 0 1047319 328407636 +205268932+137827542+0-69475733-233141-69477859+553681843+68824058+344157832+205165877-70186912-1548282-70290842-1182544+689607230 kem_6960119_enc 0 194 164707 +631-4743+0-5590+5506+6038+18870-5773+5605-187+2593-171-3260-5690+197 kem_6960119_dec 0 194 297588 +21936+1924+268-150+382-675+72-1114-1496-1236+0+124+169-960-459 kem_6960119 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair 1 1047319 302102715 -59592283-119982081+0+121381221+121242482-119035004-59671097-60142422-119784943+448474-59924953+428447102+513608+119690125+120087943 kem_6960119_enc 1 194 132086 +2698+0+6966-3309-663-733-1094+1160-526-902-1026+3704+1443+4379+35108 kem_6960119_dec 1 194 269050 +13003+2776+913+504+173-511-196+0-149+64+208-388-317-3-134 kem_6960119 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119_keypair 2 1047319 1627235007 +468189+928491-387773770+390177199+1168462138-387580582+1167501873-318591-388194983-387628871-388673519+0+5447725181+779086427-387926632 kem_6960119_enc 2 194 390965 +27021-8043+1171+69367+46107-10665-8733+0+10005-10697-721+63084+17802-747-10804 kem_6960119_dec 2 194 2365278 +40603+7301+6990+4127+1436+712-1582-3966-1548-397+3447+0-3482-906-268 kem_6960119 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair 3 1047319 759467333 +1248528005+509319965+156326303-156046651+624458644+48983+265981-156006158-156146427-155995867+0-156066077-156033011-156057291+1092714640 kem_6960119_enc 3 194 132047 +56683+2021+49411+19486-8966+1009+0+19852-8963-10557-9404-8595-7960+18797-10322 kem_6960119_dec 3 194 1601532 +56568+13340+4544+2060+3747+779+0-511-536-677-379+1374-62-269-387 kem_6960119 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119_keypair 4 1047319 1630595168 +803980618+803534634-401904130-401984418-401877545+803010112-205058+803342205-27440+0+2008571915-401766855+68403-401528374+2008179705 kem_6960119_enc 4 194 384081 +26436+0+84542-4550-4141-5162+22498+32430+24839-4570-5022-4368+61610+4199-4146 kem_6960119_dec 4 194 2431377 +38914+12591+5283+2337+1484+824-1417-1090-899+311+0-2119-675-3103-4515 kem_6960119 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair 5 1047319 1526434021 -239551054+410424+240249090-480006574-718985671-480634595+477296443+478653182-374690+478313408+717500860+531451+0-720104121-240850455 kem_6960119_enc 5 194 220593 +3127-4213-6807+53188+0+9563-9599-9785-9749-10229+19626+19416+10150+69568-9684 kem_6960119_dec 5 194 1605620 +36292+10097+5304+3405+261+0-600-473-1127-1260+483+241-1551-1018-1443 kem_6960119f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair selected 1047319 186150802 -315623+0-152632-285826-341073+126169+231527-390514-27435+1421+309180+81080+57032+478962-238005 kem_6960119f_enc selected 194 132152 +10339+0+2237+4489-175-612+4732-727-1160-527+4627+4918-445-279+2106 kem_6960119f_dec selected 194 269189 +17541+2566+526-474+125+1+0-237-702+346-473-425-255-483+48 kem_6960119f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119f_keypair 0 1047319 244511400 +467172+485689-5718+1137583+431879-21698-261360-230582+0+283100-145096-315458-107113+272907+1127659 kem_6960119f_enc 0 194 165415 +10098-2868+5289+0-2397-2986+182-2987+210+14380+13179-2275+5553-2574-2346 kem_6960119f_dec 0 194 297211 +17250+1120+570+303-27-1119-795-686-68+0-348+168-70+59+355 kem_6960119f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair 1 1047319 186075827 +145159+194843-24362-197058-59693-201843-12667-25868+0-112790+164599+374123+349972+1458+159622 kem_6960119f_enc 1 194 134376 +7439-2192+0+2265+5224-925+7788-123-695+2427+10730+2341-3442-165-3258 kem_6960119f_dec 1 194 269256 +10535+2914+528+610-54-681+0-648-196+106+44+294-204-3-533 kem_6960119f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119f_keypair 2 1047319 1299617744 -311065+44309-857912-607665-233373+317820+956258+629404+419022-77660+312392+125031+0-349134-660059 kem_6960119f_enc 2 194 392517 +0+83091-9585+19305-9626+24904+26618+81+27068-10117-9617-10226-2742-10562+41385 kem_6960119f_dec 2 194 2364293 +39555+10060+6381+1948+1788+216+0+989-64-796-906-1741-4845-1234-1330 kem_6960119f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair 3 1047319 617609980 +476239-38621+237834-4655+0-133415+444734+73110+99042+40766595-74787-65606+119456-147270-39997 kem_6960119f_enc 3 194 137371 +101623+2358-8349-8840-9505-8620+32137+22473+0-9434+30358+49292-8917-9195+19585 kem_6960119f_dec 3 194 1601209 +37580+9438+5258+2052-33+0-200-114-527+1283+20-338-119-396+41 kem_6960119f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119f_keypair 4 1047319 1275116258 +184078-689315+0-203190-439803-59246+114375+360254+304233+418407+223399-16310-4943+368987-61923 kem_6960119f_enc 4 194 398336 +72895-9615-18784-17508+367-18481+64622+0-18997+27610+19607+17233-18121-9302+17493 kem_6960119f_dec 4 194 2430619 +38582+9454+4627+411+799-2062+1478-1268+0-796-3548-1419+1139-203-3088 kem_6960119f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair 5 1047319 798726964 +180390+142458+410750-104143-114642+59074489+296158+18451737-2141224+0-429997-1979020+82500-1762078-1893149 kem_6960119f_enc 5 194 221036 +1712-5362+24998-10342+0+48285-10229+18814+48121-733-863-10741+20127+29228-10969 kem_6960119f_dec 5 194 1605388 +35408+9956+4401+1036+800-290+1448-175-406-527-988-738-1064+12+0 kem_6960119pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair selected 1047319 374273328 +720746711-67951618-67822684+60463161-128228606-188463919-188314082+594904858+112898937-188463062-7818481+0+113105792+52999486+113543619 kem_6960119pc_enc selected 226 144721 +12489-104+2517+0+4886+6375-59-197-129-217+5002-282+2204+10716-165 kem_6960119pc_dec selected 226 281110 +16142+2721+514-17+0-294-340-155+34+741-116-231-124+190+112 kem_6960119pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pc_keypair 0 1047319 398423026 +346173063+0+138430003-139008837+138243970-264804-69349259-139683871-633124-139591389+136287863+274576953-1799229+67687838+274215081 kem_6960119pc_enc 0 226 178224 +4110-2112+0-3349+38155+785-2039-3600-2908+18930-3926+3098-751+2333+1370 kem_6960119pc_dec 0 226 309323 +15897+2573+880+0+196-887+164+432-837-45-234-178+35-552-260 kem_6960119pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair 1 1047319 367304680 +60177148+119981735-120950933-60334668-833936-181487054+58438784-181414415-121149063+0+118542317+59504472+120094962+59778780-61168416 kem_6960119pc_enc 1 226 144822 +3462-169+2117+0-622+23269-385-771-1008+2037-635-926+1581+4639+12271 kem_6960119pc_dec 1 226 280984 +10672+2372+659+39-71-282-151+0+185+211-210+8-129-100-576 kem_6960119pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pc_keypair 2 1047319 1635700059 +1956800658-391032007-392093094-392692003+782282101-613425-968419-1040651+1564321591+0+1564600287-391970963+390375544+3913597012+4800284754 kem_6960119pc_enc 2 226 404637 +55621+30102+0-12022-9636+17533-10399+8667-366-10834+115517+8654+7330-9419-10427 kem_6960119pc_dec 2 226 2380285 +35464+11692-2249+3030+2858+2654+1876-7100-1735-745+0-568-7840+2064-606 kem_6960119pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair 3 1047319 775690009 +322313623+644219111-161261863-44184+160978974+805439210+644388797+0-161196481+322029493+1288750494-234060-161248008-142037-161266617 kem_6960119pc_enc 3 226 150081 +40514+5387+32264+39658-9351+9784-9830-1225+18817+9110-9346-50-9124+0-9536 kem_6960119pc_dec 3 226 1611710 +34164+8644+4627+3394+1410+122+0-161-294-452+1271-142-385-147-305 kem_6960119pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pc_keypair 4 1047319 2032100666 +2008635811+1607990694+2812704358+401594967-803777346-401618084+304099-803118798-401751330+0+527638-401610088+402292806-401549998-803197088 kem_6960119pc_enc 4 226 402954 -1281-6902+23260+0-9808+45506+7984-10786+16809-2485+26264-1519+8490+7794-10898 kem_6960119pc_dec 4 226 2449368 +36525+10025+7373+2097-6490+988+528-1200+390-96+0-4363-357-1059-899 kem_6960119pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair 5 1047319 1285354166 -477950424+241517387-239305956+239661072-478485829+1198201859-478666091+0-239451484+479307625+240236991+479594595+479595601-478571990-640424 kem_6960119pc_enc 5 226 241993 +8886-16263-6861-19334+11194-19008+8788-20151+20624-19089+40494+58895-8723+0+9308 kem_6960119pc_dec 5 226 1618508 +37171+9813+4785+1576+549+1685-282+0-298-475-629-647+1224-613-647 kem_6960119pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair selected 1047319 186081216 +183892+16690-49934-85891-26615+35592+34227-256213+14053-188192+33654+181506+0-211768-141500 kem_6960119pcf_enc selected 226 146067 +2540+3316+8212-1851-2350+5628+206+0+9827-2805-3079-2661-322+395-261 kem_6960119pcf_dec selected 226 280981 +17074+2738+530+67+0-6-63-181-194+115+84-114-146+110-303 kem_6960119pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pcf_keypair 0 1047319 245148086 -721390-775214-279748+481177+413110-80868+0+498701-799367-45819+352314+484715+549183+358878-880970 kem_6960119pcf_enc 0 226 177559 +1316-2258-2633-2215+8193+6661-1799+1764+0+534+2631-2781-2695+289-2487 kem_6960119pcf_dec 0 226 309412 +15404+2340+1328-1184+412+176-818-332-1179-789+0+128-207-375+301 kem_6960119pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair 1 1047319 185950185 +378019-220306-202618-62998+58181-59265+342069-37012+304586+0-178018+478398+202394-12422+280240 kem_6960119pcf_enc 1 226 146856 +0+15613-3145-3758+2055+4562+10722-3502-1197-1453-1020-541+667+14139+2250 kem_6960119pcf_dec 1 226 280944 +10723+2062+789+366-12+418-125+0-243-166-81-480-140+205+45 kem_6960119pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pcf_keypair 2 1047319 1299738927 -39863+626374+0+83762+266324+421934+243857-922804+600822-492457-524773-737940-639163-912869+102893633 kem_6960119pcf_enc 2 226 411919 +15203+42419-16760-19574-8157+37731+0-19279+1452+1060-18636+46296-16541+19733-18534 kem_6960119pcf_dec 2 226 2381016 +38085+8378+2583+1924-5818+1727+0+651-335-7240+158-1158-504-958-8086 kem_6960119pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair 3 1047319 617623831 +200099-347055-159652+281885+2463-202171+148920-318686+0-283743+257604-193616+473013-33247+68273 kem_6960119pcf_enc 3 226 150165 +40308+22863+10797-10077-9240-468+18516-10067-10200+10240-10200+10357+0+28506-9944 kem_6960119pcf_dec 3 226 1611787 +37259+10259+4466+1619+1128-36-203+0+909+473-214-88-461-706-504 kem_6960119pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pcf_keypair 4 1047319 1275678744 -66495+154734+7641-302576-272938-239922-108615+56293+0+129555+480890+79608+206527-223833-993 kem_6960119pcf_enc 4 226 411341 +27442-17741+3751+147+47435-8975+8206-18283+9863-19662-431-9770+0-18556+28135 kem_6960119pcf_dec 4 226 2449601 +36052+3060+6052+3185+2695+5207-8082-69-314-1119+0-6534+264-854-1836 kem_6960119pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair 5 1047319 797201643 -356951-312718+1145968-485362+17740076+1607077-275601+0+1784883-308979+1092421+1634577-163781+1713205-379431 kem_6960119pcf_enc 5 226 235983 +0+49859+8637-12059+17468-11981+36999+7836-11903-3092-12685+6698-12240-12516+7320 kem_6960119pcf_dec 5 226 1618776 +37331+10210+4300+2009+600+1732+0-373-54-404-705-1428-325+724-938 kem_6688128 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair selected 1044992 366128418 +695743-69403429-138921475+1180362+210489279-68663999-69831143+71536242+69746224+0-138975898+211171980-69729347-139368809+490724533 kem_6688128_enc selected 208 122780 +681-2349+905-5755+3830-2806+20069+3156+60-3331+3816+0-2499-2910-5701 kem_6688128_dec selected 208 292848 +13786+2150+1267+231-2286-163+3+106-98+34+0-128-75-85-161 kem_6688128 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128_keypair 0 1044992 443727458 -80592174+318256022+241336482+0-160469930-160157055-160094461-160248801+159409539-158853149+161610359-159519794+81742900+638073770+78551433 kem_6688128_enc 0 208 160241 -4838+26191+6171+2737-586+14769+2855+2447-458+3065+0-7241-7732-7173-3954 kem_6688128_dec 0 208 327145 +14647+3043+871+438+0-332-467+452-7-363-723-325+88+79-627 kem_6688128 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair 1 1044992 296331070 +350769692-69228919+70505555-69687581+350689092+349839237-69197569+0+71260489-69789446+139949775-69779932+70727380-69293814-347918 kem_6688128_enc 1 208 122837 -317-2147-5040+11950+17359+1196-2404-3138+128+3819+246-5517-5391+3336+0 kem_6688128_dec 1 208 292881 +10782+2187+840+395+61+0+69-33+3-100-35-52-205-38-128 kem_6688128 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128_keypair 2 1044992 1771978974 -432436748+435281563-433068867+435532652-432220549+0-432181479+1737133985+2602391432+1303441466-432396701+2606634145+434040958-432448430-432459281 kem_6688128_enc 2 208 432320 -10355-14985-16750+61462-8095-8355+20733+39130+0-8604-17671+1141+19468+10616+10494 kem_6688128_dec 2 208 2514503 +31849-6767+18529+19180+14212+13815-28813+12140+0-8753+11389-47696-210-8822-8825 kem_6688128 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair 3 1044992 869228505 +2357136897-205205+392699536+589238436+1178533588+0-118934-196688925-196518611+196413618-196582584+392710465-196563617+392810517-194142 kem_6688128_enc 3 208 135109 +27268+25501-373+0-10940+33286+28+21854-170-11725-11057-11253+11056-11517+44455 kem_6688128_dec 3 208 1655719 +33945+8548+5736+2060+293+307-277-112-213+597-312-180-347-232+0 kem_6688128 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128_keypair 4 1044992 1813802066 -464000446+2320422131+0+1857562362-464510367+1392948490-522115-464464621+2784744344-464294091+166425+276534-464216655-228206+463837141 kem_6688128_enc 4 208 391312 +33523-2446+0+26670+86318+17382-2064-3901-3069+148780-14612-2487+6899+7097-14017 kem_6688128_dec 4 208 2590660 +29625+17925+8668+4532-1020+0-11882-2031+4309-11263-131+2970-15123+4001-3535 kem_6688128 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair 5 1044992 1410246763 -548572655+272610466+272458940-274913587+0+1914858876+1168421954+820067743-547903209+1095202064-548883851-274896249+272498328-985641-274583998 kem_6688128_enc 5 208 223081 +2931-19203+15646+774+22168-21814-22425+11026+22774-22786-10379-22214-21930+23468+0 kem_6688128_dec 5 208 1675539 +45831+14403+8450+4600+2707-58-131-8-872-518-9+2869-549+0+269 kem_6688128f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair selected 1044992 226941450 +125414-110843-328141+824591+561406-212080-468827-274790-187978+442815+592577+0-145647+238113+69608 kem_6688128f_enc selected 208 120671 -683+0-186+7610-3125+4467-906+1782+1582+18015+8496-4235-3411+1876-945 kem_6688128f_dec selected 208 292827 +17180+2554+922+61+171-124-126-2116+0-123+92+112-82-101-38 kem_6688128f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128f_keypair 0 1044992 288171345 +595144+1572902+92146-251366-5365+822400+483763-279760-66116-154501-130219-53338+0+549738+1574298 kem_6688128f_enc 0 208 162829 -3642-9949+17538+2619-6132-3669-2841-6628+5013+6434+9048-6199+726+18717+0 kem_6688128f_dec 0 208 327088 +14976+1993+224-799-1199-1676+0-1422+242+149+460-230+197-238-141 kem_6688128f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair 1 1044992 226978770 -227055+771234+59724-157412-519644-689255+280151-312626+0+165892+95994-308840+570962+229789-4232 kem_6688128f_enc 1 208 120411 +9179+139-3378+3527-3306+0-3620-3377+7693-2996-3179-3396+15429+32004+2801 kem_6688128f_dec 1 208 292770 +11378+2178+865+406+100-214+119-40-6+245-241-150+0-111-46 kem_6688128f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128f_keypair 2 1044992 1420227162 -612368-1530321+137485+0+155589-1732075+201681-316602+712769-654352+1376313+3295111-180478+873888-1501093 kem_6688128f_enc 2 208 424097 +53025+9351+37457-9621-10371-10133+9302+28321+0+150-82-10093-9938-641+1663 kem_6688128f_dec 2 208 2518249 +47597+0-47586+14394+9884-16098-43853-4847+7285+11483+7661-19131-51518+8448-38983 kem_6688128f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair 3 1044992 675700858 -750907-868457-110646+79067-138343-98705+166870+244901-801209+447077+9723+82618+100399-659299+0 kem_6688128f_enc 3 208 145135 +31444-21288+122840+562+55740-22181-10534+446-22042+0+826+21225-11094-10791-21580 kem_6688128f_dec 3 208 1655811 +34704+8617+6629+2555+1758+0-403-601-698-511-688+542+149-540-192 kem_6688128f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128f_keypair 4 1044992 1416865486 +265714+370354-41619+104587-77240-258603+467842+108121+144391-76901-163534+0-11162+365818-237548 kem_6688128f_enc 4 208 399200 -10298-15835+47487+2699+11009+2181-10734+9398-10453+20432-553-20202-21162+0+32707 kem_6688128f_dec 4 208 2592205 +42154+13856+9197-2263+3289-10277+4898+2582-12624-900-211-61+0-7102+1774 kem_6688128f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair 5 1044992 864407071 +441232+144159+166886+5910+181237+0+74707+88136-4018-257336-765640-2110133-1899205-2298416-2070428 kem_6688128f_enc 5 208 212666 +28780-7406-9270-9425-11765+22834+33189+0+32662+55909-1167+22331+21205-11652-11280 kem_6688128f_dec 5 208 1678903 +37291+14966+5938+3140+799+1404+935-3435-3044-3379-3560-3762-2306-702+0 kem_6688128pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair selected 1044992 367343643 +209089605-140207576-70217114+348885052+139463755+0-140587069-69917111-620334-69745306-139996655+69736090+349884917+69308609+139836572 kem_6688128pc_enc selected 240 131184 +5436-2806-3358-5-3161+4970-2839+14078+0+2714+6154-3031+5278-3326+574 kem_6688128pc_dec selected 240 302996 +15620+2395+734-17+136+53-76-2091-309+22-214-32+0+41-123 kem_6688128pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pc_keypair 0 1044992 442542247 -158323886-79167420+181302+162361841+479643867+974565-158456614-159189303-157687497-158932792+1779813+239685507-159301922+0+79924757 kem_6688128pc_enc 0 240 169951 +3094+13778-5936+4312-5992+0-5953+31366+12722-6105-5657-2372-6001+6927+10477 kem_6688128pc_dec 0 240 339033 +14042+2819+485+383+363-169+28+386+0-205-1149-1238-1388-623-1198 kem_6688128pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair 1 1044992 366008075 +980415212-139609247+0+897422-139194491-138721735+279550976+139945929-139128915-139311863+69888854-139394068+280450621-68710275+548207 kem_6688128pc_enc 1 240 131174 +7779+525+9064+2196-3083-399-3054-905+2243+17093+8759+0-3609-2690-338 kem_6688128pc_dec 1 240 303230 +10749+2305+525+154-190-182+17-51-6-256-2450+1192+0+92-231 kem_6688128pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pc_keypair 2 1044992 2206927595 -434486779-867692234+2167024106-434735957-434304812+164990+1733620324-867613240+434041559+434615007+0+993679829-868307933-806100+1300027772 kem_6688128pc_enc 2 240 443467 -5299+122-17445+1608+21042+0+57120-17658+67853-8993-8165-18834+29694-17128+215 kem_6688128pc_dec 2 240 2542196 +0+7628+6781+1803-27390-4424+550+3676+2704-3339+2517-15689-3548-50172-11677 kem_6688128pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair 3 1044992 869168396 -150620+196222190-86010-70287+1768122443+4124993138-10574+0+589368475+589298024-176834-196550624+2553780744-196352403+196413080 kem_6688128pc_enc 3 240 144045 +0-3559+41132-9695-7567+12584+57334+23386+920+1515-9731+45101-10394-9823-10022 kem_6688128pc_dec 3 240 1666716 +32542+8716+4464+3829+387-106-162+428-173-246+953+0-415-540-402 kem_6688128pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pc_keypair 4 1044992 1813768270 +3249410483-759296-464475607+2320656766+927895575-464582350-464276668-464158177+2320610602+464736513+2320664431+927681284-464586958+0-464528706 kem_6688128pc_enc 4 240 399779 +69998+76131-617+10790-11297+8981+19251-1123-11407-521-829+22016+0+10799-9466 kem_6688128pc_dec 4 240 2606067 +36866+15005+5396-3466+1172-4127-3725-468+5012+4804-941+0-2502+516-6554 kem_6688128pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair 5 1044992 1682859960 +273676155+1095251069-274214439-472364396-547599771+0+1914975896-546850741+1092870179+547040028-2367799-547395796-274230333+2737292789+271580612 kem_6688128pc_enc 5 240 235783 +2686+31173-22720-23519-23678-1118-11883+43214+77637+75790+32633+0-10939+75996-24070 kem_6688128pc_dec 5 240 1688360 +45788+11631+9045+1883-208+419-210-886+2067-11-181-618+0-760+141 kem_6688128pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair selected 1044992 227117130 -200305+315236-389518-450490+313553+329109+247158+267571-509733-274080-702598-496052+0+232373+37633 kem_6688128pcf_enc selected 240 131409 +8495-3125+0+2132+9197+2534-3684+5755-3436-652-3377-859+4725-3571+5311 kem_6688128pcf_dec selected 240 303076 +17109+2128+906+364+395+16-157-72-181-286-194+0-66-2+20 kem_6688128pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pcf_keypair 0 1044992 288283402 +1561113+727873-192526-84260+730358+12061379+1606713+1425616+994248-170394+0-245471-180824-180774-242116 kem_6688128pcf_enc 0 240 166209 +0-2807+1060-3359+3223-2422+61+492-2903+559-3001-2064+3402+12705-3026 kem_6688128pcf_dec 0 240 339499 +15906+1281+520-506-1219-634+145-1806+116+0+695-1410+155-156-1994 kem_6688128pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair 1 1044992 227163786 -322113-560687+138251+727894-140364+261046+484788-260469-274495+177022-354223-409513+8652723+0+409402 kem_6688128pcf_enc 1 240 133239 +12088+4138+925-2253-5420-108+667-3002+6709-5232+3329-5267-2311+181+0 kem_6688128pcf_dec 1 240 302919 +11349+0+1085+562+9+64-97-93+120-94-9-22-2064+43-28 kem_6688128pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pcf_keypair 2 1044992 1419886052 +1550297+7222616+3942876-1950195-1101917-335791+83487+0-278370+561181-1535079-981953+530135-678004+127459931 kem_6688128pcf_enc 2 240 435368 +33548+38834-8931-2143+36593-10752-11062+0+28472+9382+17861+29159-120-10774-563 kem_6688128pcf_dec 2 240 2537799 +13703+17126-9437+0+4993-6131+5557-19090-52584-12398-29602+5889-59484+508+434 kem_6688128pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair 3 1044992 675550767 +484228-148286-447875-434577+125513+0+105142+70772+114975-63834+38881-791608-287214+326258-301428 kem_6688128pcf_enc 3 240 156355 -9189+44910-10270+10945-10957+33698+55582+288-21660-10910+0-21486-10646+33334+34368 kem_6688128pcf_dec 3 240 1667016 +34334+8696+5495+2837+150-429-153-128-581+121+1133-46+0-683-367 kem_6688128pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pcf_keypair 4 1044992 1417239329 -32387+229072-12234-218686+30950-181689+270762+296481+53575-136655+256735+231273-243466-97176+0 kem_6688128pcf_enc 4 240 418486 +53230-18721+2264+20522+2932+21240-19676+0+33531-18667-20612+81387-30117-30590-8102 kem_6688128pcf_dec 4 240 2606543 +33956+14682+785+4976+2081+1737-7290-8125+0-5668+219-19422-206-18648-9227 kem_6688128pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair 5 1044992 864169922 -1791624-1846646-1826278-1960672-1512421+122486-87904+44063+267749+117609+330539+0-84581+164559+72042 kem_6688128pcf_enc 5 240 225104 +64933-9944+0-11313-11455+410+78285+12097+10791+10700+930-11925-11214-952-165 kem_6688128pcf_dec 5 240 1688152 +43442+16159+8651+1453-171-158+54-338+922-71-227-523-843+0+475 kem_8192128 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair selected 1357824 308181155 +69638091+18371-70022808-70024935+70166174-69871160+139567711+69904354-69764984+698601047+0+558439118-431909-492540-69946323 kem_8192128_enc selected 208 142248 +1859+884-1955+1222+387-447+0+6860+1125-1074+77-172-2426-1913-2028 kem_8192128_dec selected 208 290506 +15447+298-796+636+0-1224-1858+101-1828-682+232-1294+185+116-991 kem_8192128 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128_keypair 0 1357824 391527853 -79501321+318074450-79003+41991+159012140-78544291-78551708-78362141+1544667+318826524+160737+318094675+0-78853966-78245399 kem_8192128_enc 0 208 217490 +289+182-1995+2780+0+1675-1887-654-2020-361+3020-1007-1599+6251+2924 kem_8192128_dec 0 208 322701 +13654+1729-273-825+270+186+0-897-1055-256+304-906+86-208+236 kem_8192128 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair 1 1357824 377922995 -70461041-139741418+69462693-70215723+69793197+350030263+139380003+139783905+0-14992-139980480+244473-214299+628374923-139785892 kem_8192128_enc 1 208 141309 +1941+2568+2723+3441+4439-295-972-1250-865+0+6037-1374-1088-788+944 kem_8192128_dec 1 208 290282 +8626+3503-514-1116-1242-104+0+386+562-1438+537+304-1047-1091+421 kem_8192128 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128_keypair 2 1357824 2848267182 +3528404442-1322623486-1322430332+3968399772-440570508+2646610129+297092+4410934132-881799352+1764798989-881273026+479191+0-1322891313-881565436 kem_8192128_enc 2 208 639256 +49095-6951-269+64359+39648-1361+0-10139+6739+89166-1308-1236-2025+7219+31076 kem_8192128_dec 2 208 2430479 +40540+12838+7273+3814+5676+3888-390-1542+2831+0-64-1406-4048-845-2410 kem_8192128 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair 3 1357824 1155652021 -383363498-191656451+767101521-191539558+383568040-383326506+0+58235+1533703139+1342166140+766877182-191454981-191575356-383326658+191837938 kem_8192128_enc 3 208 153916 +40932-6934+1816-8839+28021+0+27050-8938-9273+8625-9281-9446+236+334-9048 kem_8192128_dec 3 208 1648009 +37018+10294+4958+2587+1920+23-77-591-438+0-205+603-428-319-386 kem_8192128 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128_keypair 4 1357824 1957560472 -479496631+479474592+3356845108-479689905-479688033+479333255-247393+67115-479758699+479641450+1917944196+958923118+0-53810-479743036 kem_8192128_enc 4 208 455878 +115721+1770+33339-180-313-202+15785+0+8018-153-267+17029+16236-321-470 kem_8192128_dec 4 208 2468278 +39354+10671+6862+3575+83+1523+1967-392-2855+0-1022-626-2141-5813-1824 kem_8192128 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair 5 1357824 1474450097 -551812924-551792302+556723687+0-551914167+556719770-276041609+227688+828754867+5171016-275898541-552015249+832887162-547015585+828757447 kem_8192128_enc 5 208 244363 +44108+30322-6543+534-8647-8467+17566-8528+903+0-15-251+34064+33542-7916 kem_8192128_dec 5 208 1652776 +36530+8940+4537+3089+701+0+987-169-1008-544-1092-1007-259-794+521 kem_8192128f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair selected 1357824 237902095 +8946+174204-213743+210649-259265-203969+83212-77132-154013+12399+0+106621-173515+145689-23762 kem_8192128f_enc selected 208 142932 +1558+1488-2563-1627+1955+4269+9424+1201+1766-2371+0-2597-1124-1584-2726 kem_8192128f_dec selected 208 289192 +19858+3343+189+1164-280+0+866+986-636-540-898-524+1097-862-534 kem_8192128f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128f_keypair 0 1357824 333372905 -211894-382536-243412-312432-196497+0+352070+9940518-304306+539731+493740+647907-235319+498818+239254 kem_8192128f_enc 0 208 218142 +3438-583-2096+1092+739-2289+707-962+2118-2019+864-2887+0+8107-1302 kem_8192128f_dec 0 208 322846 +15911+2204+473+551+345-251-708-335-529-1243+277+639-144-239+0 kem_8192128f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair 1 1357824 237907553 +8171536-134097-275422-203774+165645+0-301092-312970+315171+93745+327212+49350-17841-216677+172504 kem_8192128f_enc 1 208 140994 +1924+691-225+1216-52-947-995+2934+3043-675+97+0+1936-1173-748 kem_8192128f_dec 1 208 289825 +12041+914+679+702-931-692-1086-1117-584+0+344-731+748-495+302 kem_8192128f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128f_keypair 2 1357824 1631794826 -1735210-1158519+501823+460348-230225+93855+424740-697135+0-64985+753726+53710-188019-1086818+520004 kem_8192128f_enc 2 208 646329 +15795-3239-15952+576-16048+4+629+0+24180-366-9069-9231-7363+7008+23901 kem_8192128f_dec 2 208 2433691 +36151+6392+212+2245+5243+4894-232+553-4572-8566-1643-3167+0-1314-5571 kem_8192128f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair 3 1357824 687486257 +186+78306-37153-94539+6372+154814+105368+0-19788-76584-80109-25411+84601-71930+84936 kem_8192128f_enc 3 208 160182 +0+6468-14079+4886-15553+2888-6584-6452+12154+39292-15898+11796+2598-6512-15552 kem_8192128f_dec 3 208 1649129 +43214+11676+5492+1175+480+0-863-352+568+610-265-845-875-443-375 kem_8192128f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128f_keypair 4 1357824 1602491065 -1456096-1543911-1690390+1752999+3046035+2785+153811-1052052-1364179-2268712+1988772+932564-2514761+0+201277 kem_8192128f_enc 4 208 464129 +2795+58504+58272+7732+7633+7348-8563-8574-8418-8512+7399-669-8490+0-8733 kem_8192128f_dec 4 208 2469271 +39850+10286+4564+2037+1056+0-1675-697-4483+1351-5326-1296-2524+277-1311 kem_8192128f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair 5 1357824 920236661 +331213+78480-115263+75602613+0+74248+179556-253579+93154-12724-25581+15455-194586-70798-16291 kem_8192128f_enc 5 208 253100 +29813-12552+18865+9043-8353-17202-313+17078-8410+8440+0+25565+16749-8498-17195 kem_8192128f_dec 5 208 1653693 +38624+12158+4973+2654-51+34+288-672+9-691+0-1060-339-1512-1499 kem_8192128pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair selected 1357824 377928374 -140127719-140117458-69880083-70315126-69890787+418766230+69069089+463909-151327+69725300-140294707+0+70218221+70763208+139238475 kem_8192128pc_enc selected 240 162156 +4228+1691+4097+1699-1356-1252-2018+2907+96-2211+0+19-1346-2222-2053 kem_8192128pc_dec selected 240 301784 +18497+2113-592+1079+0+2-1208-535+369-1348+227+293-214-1028-1321 kem_8192128pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pc_keypair 0 1357824 312616556 +636222720-783486-948095+159287355-105838+79274278-59041+320616254+478163733-796086-825353-799363+79438455+0+78818832 kem_8192128pc_enc 0 240 236806 +4868-868-767+1050+3703-331-240-1473+1042+1352+1364-1020+4314-139+0 kem_8192128pc_dec 0 240 334699 +14727+2527+1146+337-291+661-179-159+296+0-452-13-140+162-630 kem_8192128pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair 1 1357824 385895674 +386512+420405517-7937424+61498105+60941446+0-7325015-77957181-8068194-8209023+61403781+61563767+340744903-147927630-148275286 kem_8192128pc_enc 1 240 162050 +0-1398-2035+973+1059+3343-2131-1799-1747-2015+2828-81+257+154+3883 kem_8192128pc_dec 1 240 302144 +10507+1037+709-1033-410+504-655-1370+840-738+105-1050+0-1795+389 kem_8192128pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pc_keypair 2 1357824 1973822649 -445144649+889562712+1779943043-444395481+1333513440-444246904-672453-118798+4448210753+444747715-445374198+0+1334374725-542880+4891869586 kem_8192128pc_enc 2 240 649519 +13714+29457-7634+40947-7162-7288+17314+48325+24027-7304+1494+0-7256-7165-103 kem_8192128pc_dec 2 240 2448211 +36977+9486+8678+5615-314-2166-768+1242-3209+215-2231-616-8259+0+221 kem_8192128pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair 3 1357824 957341416 +37669+195835589+1174519793-195797283+195775622+195897798+0-42948+116049-195720309-195688933-195701057+195871396-195752348-58298 kem_8192128pc_enc 3 240 168911 +32525-4434-6819-8876-8934-8944+18631+55260+46226+9108-8997+0-8651+536+421 kem_8192128pc_dec 3 240 1662717 +38442+9896+4610+1617+376+0-388+1170-790-840-1105-1060-315-934+868 kem_8192128pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pc_keypair 4 1357824 1949908663 +476380077+0+952280502+476216406-476291262-476231634-39949+476172195-476155597-476251948-476170244+2856896293+476021098+476244483-61566 kem_8192128pc_enc 4 240 483590 -3924+0+47059+80982-8001+7794-105-8404+15727+16752-16306-8226+7910-8486+31958 kem_8192128pc_dec 4 240 2485164 +35038+7049+2588-6155+782-1061+883-4411-2090-3877-1954+702+1639+0-2250 kem_8192128pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair 5 1357824 1485255045 -556995327-278532714-33411-557401103+1114137832+1114447598+111808+370184-557433549-278565515+64938+911591308+278879844+0-523630 kem_8192128pc_enc 5 240 260290 +13572+1545+0-11026-2183+5889-2037-11861+5699+5351-11856+14149-2996-2920+5589 kem_8192128pc_dec 5 240 1660435 +34071+9340+4898+2545+1238+2496+0-230-182-235-322-80+757-352-930 kem_8192128pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair selected 1357824 237726942 +313414-122839-129566-297176+91809-184883-140810-160597-269899+49774+0+215024+96360+124834+7738 kem_8192128pcf_enc selected 240 163175 +1564+594+0+3766+1144-2024-2115+4940-2016-1925-1261-1013+1092+1013-1260 kem_8192128pcf_dec selected 240 301937 +17590+1076+2712-1268+746-1222-150+245+0+66-169+270-1575-1638-1295 kem_8192128pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pcf_keypair 0 1357824 333245099 -28627-127937+31997-278741-291581+0+856051+453798+684720+738426-289339-295056-158810+717510+452952 kem_8192128pcf_enc 0 240 236546 +5449+573+5626-86-1186-1561-345-57+3623-229+936-957+0+3330+49 kem_8192128pcf_dec 0 240 334921 +16171+1944+1303+256+644+181-203-19-554-42+71-72+0-60-382 kem_8192128pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair 1 1357824 237804821 +0-59289+125913-21994+24592-292337+184732-326703+356574+145922-136435-117569+256440+177667-116453 kem_8192128pcf_enc 1 240 162112 +2117-553+2128-73-978+1150-903+931-1414+196-1380+771+0-1246+1712 kem_8192128pcf_dec 1 240 302118 +9652+2649+484+981+341+75-1587-213+411-1456-1003-1116-378-51+0 kem_8192128pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pcf_keypair 2 1357824 1632103888 -1946035+112014-427655+282084+536077-101774+198588-1460703-547045+0+96038+19077+574010-223035-301719 kem_8192128pcf_enc 2 240 652451 +0+13015+14796-2878+32217+29325+4963-3323-3134+21012-3384-3267-3229+36960-10120 kem_8192128pcf_dec 2 240 2450595 +36170+7917+5129-2028+1409-1974+0+335-1582-2549+233-2125-3668+204-2475 kem_8192128pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair 3 1357824 687224184 +64938-45096-120514-32581+0-44008+4968+126282+14458+30268+35774-112147-15838-32354+58780 kem_8192128pcf_enc 3 240 179466 +40533+12093+19393+36480-508-19144-19115+35614-10109+0+8100+7559-9235-9875-19185 kem_8192128pcf_dec 3 240 1663410 +35476+8185+4488+1648+184-158+1196-765-475-502+0-942-449+388-461 kem_8192128pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pcf_keypair 4 1357824 1602716801 +151953454+1722625+0-2073251-1070280+93784-1281116-40992-2717721-820066+1980611+2370686+640317-1609813+2235861 kem_8192128pcf_enc 4 240 478429 +20203+0-9954-10899-9550+5270+44677-11212+5198+4848-3384-11082+20452+36588-3234 kem_8192128pcf_dec 4 240 2484488 +40766+7692+5357+1403+3699+1322-4570+2032-3160-850-4886-9152-1661-2062+0 kem_8192128pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair 5 1357824 920214879 +6023+0-250105-62036-403465-88596+76523+57486+79718-288201+20966-338502+22889+10275-245441 kem_8192128pcf_enc 5 240 266357 +9120+6145+1612+0-17414+85622-17645-17724+58967-17538-9087+7887-17717-17450+8264 kem_8192128pcf_dec 5 240 1660162 +36184+11899+5311+1894+1403+275-693+0+1080-180-385-748-1247-986-1582 kem_460896 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair selected 524160 154445270 +0+188741731+94583281-63071387-63017498+383587-62975441-31625592+62909212-109454-63077976-63044748+31358006+31423373+31142198 kem_460896_enc selected 156 67275 +15849-3412-4322-4314+12293+7244+0+107-138+368+3363-4093-1654+11361-222 kem_460896_dec selected 156 245204 +20135+2955+1016+652-54-216-184+0+354-232-130+587+485-29-249 kem_460896 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896_keypair 0 524160 170381972 +113008736+150699631+640362337-37574404-37626230-9806+37748945-37562082+150603360-37743091+37815746+0-37607926+150773224-37700105 kem_460896_enc 0 156 82040 +10823+36061-91-163+3251-396-476-86+7257+3326-344-510+4355+0+11910 kem_460896_dec 0 156 273524 +14789+2624+2437+1437-109+0-238-2255-635+745-479-534+80+763-1278 kem_460896 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair 1 524160 123106053 +94334446-31715769-31626596+31475613-252637+31367746-31785596+126312642-31760376+125359500+0-31748708-223596+157330330+31391492 kem_460896_enc 1 156 67291 +14051+11739-4346-4432-4466-28+4365+0+15430-4399-4161+233+7553+3133-4868 kem_460896_dec 1 156 245505 +10755+1384-159+41+104+0+345-648+210+485-461-297-81-27-159 kem_460896 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896_keypair 2 524160 1115539612 -826380+41127-602958+131909-203773248-407460631+0+34541482-203865002-381686975+515826+204116924-408015510+621729334+396281 kem_460896_enc 2 156 194962 +88159-8069+22148+8788+321-8691+0-8994+16737+33772-8835-8354-404+471-8377 kem_460896_dec 2 156 2276435 +36041+13632+3780+3123+1768-4446-82+993+0-532+152-891-2993-2408-2142 kem_460896 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair 3 524160 504589299 -99380164-22127384+364129616+286967075-99381887-99491063-77196562+55100387+463558246+132378392+209771518+209650628-77199328-99500125+0 kem_460896_enc 3 156 91042 +3999-16801+3030+30542+881+21628-140+0-19539-18259+43-18025-18284+2013-18404 kem_460896_dec 3 156 1481088 +37704+8764+6674+1118+326+0-699-596-395-240+1317+297-802-579-763 kem_460896 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896_keypair 4 524160 1071652133 -387535419-392367538+196689370+455646-388193601-196271797+196441098-196185862+1178213383+289992-392599966+196397750+196258770-392584805+0 kem_460896_enc 4 156 206073 +13049+6901+33219-10037+54033+31605-1145-18843-9557-10227+0-19247+9915+9318-19149 kem_460896_dec 4 156 2304431 +42116+23926+0+15916+14864+15847+15086-10042-40544-2176-32575-2642+14371-3279-4356 kem_460896 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair 5 524160 622648164 +109156254-349711+0-344403+547365640-109419021+219061930+766239630-109698653-109851606+876040431-109829595-394935+219110100+438169001 kem_460896_enc 5 156 105489 +11731-7586+68278-1339-1090+0-830+28569+17739+9048+35045-10740-9849-9709+17237 kem_460896_dec 5 156 1490954 +37540+9343+4533+1643+747+169+0-967+1168-693-944-1006-1396-1034-619 kem_460896f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair selected 524160 91667032 +56642+39878-116100-104677+44422-80789+87456+38040-120652-18196-49261+33734+173057-149152+0 kem_460896f_enc selected 156 70984 -1178+1044+10500-7761+13501+7370-8365+19893-7723+0-3744+1155+8797-7537-3794 kem_460896f_dec selected 156 245708 +18271+2586+771+95-804+160+0-566-300-576-385-269+236+142-365 kem_460896f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896f_keypair 0 524160 130916579 -29363-65515+30954+24179+97736-22787-4233-17072+46106+0+102470+42073+23383-99873-98804 kem_460896f_enc 0 156 86051 +14125-224-4913-3701+4055+3079-4070+15742+6331-4110+0-5346+3572-4719+8539 kem_460896f_dec 0 156 273763 +13799+1387-250-878+704+143-1723+458-936+382-1456-650+0-1050+720 kem_460896f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair 1 524160 91733807 -62166+53640-18230+119932+0+5157+13527-72252-62336-112978-161104+22726+55761-174547+84608 kem_460896f_enc 1 156 67696 +1556+11294+3820-4437+11779-4564-1154+12903-4725-4573-822+7814+0-247+23771 kem_460896f_dec 1 156 245620 +11010+1524+533+1609-9+120+156+467-432-349-187+0-629-67-290 kem_460896f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896f_keypair 2 524160 707936042 -175097-556012-180872+207963-530345-577402+229506-29690+37230+164160+0+816662-100747+212422+259528 kem_460896f_enc 2 156 203222 -8859+16800+14016+3795-17542-162+25838-4485+31213+857-7672-8248+45892-12503+0 kem_460896f_dec 2 156 2277982 +39738+14447+4365+1687+587-1090+0+2383-1926-4983-3287-8978+1475-2181-3401 kem_460896f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair 3 524160 404448193 +120300-17786-54071+0-46189+55404-79053+82449+153043-49284-41768+33538-7477+10242+288033 kem_460896f_enc 3 156 91792 +84238+42+0+10061+22136-10199+3386-19359-10002+235-10435-9999+18715-20096-19784 kem_460896f_dec 3 156 1480879 +34497+8889+5564+3993+1359+0-616-159-178-278-512-646+1397+158-704 kem_460896f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896f_keypair 4 524160 704970015 +1511899+64735+703597+692288-165747+0-51196-1306061+137933-792599+1070735-633995-120043+890108-228647 kem_460896f_enc 4 156 195988 -1712-5605-7131+11141+10945-9434+10094+9244-8778+21700-8610+0-8182+65596+9189 kem_460896f_dec 4 156 2300059 +35297+26782-5153+23136+19384+7409-1126+18175-1934-2362-35463+0+17329-675-4833 kem_460896f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair 5 524160 505999626 +176306+0+234066-299766+118308-53618-32176+161873-31646+30728-88314+254315+35483-122858-193234 kem_460896f_enc 5 156 112644 +24102-6651+30496-17029-7291+1091-18004-7752+37962-17426+8896+0+1075+10223-17655 kem_460896f_dec 5 156 1491162 +32567+9421+5032+1542+414+0+1891-41-548-1008-1016-600-811-1051+242 kem_460896pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair selected 524160 123023382 +80801-31643590-149229+188471677+31370623+0-31515283+62806724-31541745-31440569-31519872+62949593+63086103-31604745+61566 kem_460896pc_enc selected 188 79087 +2336+11089+12879+20817-3224-7630+0-7796+664+5590+24404-7864-4359-8154-7908 kem_460896pc_dec selected 188 253070 +13603+2164+227+51-366+418+31-191-197-83-403+193-340-318+0 kem_460896pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pc_keypair 0 524160 207935880 +270644834+75641572-75192638+37704322+226074307-75213884+37865762-37531353-75169486+0-37527650+113078490-75268341-75136501+75442008 kem_460896pc_enc 0 188 90616 +2539+16388-1021-590+3095+7667-627+23264+0-1190-860-591+3034-1016+3370 kem_460896pc_dec 0 188 281560 +12913+1964+594+613-110+0-401+87+235-720+241-246-1589-39-612 kem_460896pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair 1 524160 123141419 -31747419+188813901+351469543-317804+251650562-31633391-272327+157318939+188633232-286484-286348+189305420+0-31764655+31155146 kem_460896pc_enc 1 188 76312 +12920-670-5641-1197-5668+20177-1487+3389+0-5074+7344+2225-4957+14553+2488 kem_460896pc_dec 1 188 253108 +10905+2560+276-305-61-302+184-176-436+96+114+29+0-179-137 kem_460896pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pc_keypair 2 524160 911164456 -204450779+611964012-204056795+52520-204502162-204277101+1484695542+0+620903483+204542546-203379407-203792295+213255564-196630157+1186153 kem_460896pc_enc 2 188 203153 +12628-6243+9925+9249-8635+0-9067+24819+15644+25487-456-9204-384+16099-8670 kem_460896pc_dec 2 188 2287582 +33745+8868+7370+2093+5820-32+718+0-5550+613-2989-2071-1048-6628-1072 kem_460896pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair 3 524160 559593633 +540878042-154395278+0-154447935-154381479+110697+77388900-154441614+77358807-154575446+154533021+154097-77058771+173811-154290369 kem_460896pc_enc 3 188 90193 +31+17966-9745-8974+0+19771+47270-485+52508+19244-10391-10191-10629-1517+10302 kem_460896pc_dec 3 188 1489944 +33924+8688+5112+2468+198+1405-524-708-639-647-273-539-1095+950+0 kem_460896pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pc_keypair 4 524160 875429203 -196232073+0-1218-196431238+152089+120096+392601131-196500751-196428640-196257388-196336903+392129574+196486894+196259620+785291108 kem_460896pc_enc 4 188 202678 +0+37133+15732-7738+1325+646-8084+5006-8393+926-8157+27755-8682-8349-8377 kem_460896pc_dec 4 188 2317204 +10151+16920-4533+9315+534+10969+0+12018-20735-5244-5373-41696+10974-5322-36811 kem_460896pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair 5 524160 732010739 +328438508+109415233+0+361887363+110036204-219078138-55918-219253313-109570281+219218353+547298503-219215518-219209072-185851986+109403456 kem_460896pc_enc 5 188 107208 +40716+17401-3653+45515-3818-3801+33689+4954-3797+0+25591+4422-4456-3534-4072 kem_460896pc_dec 5 188 1495873 +34197+9818+3988+3926+0-260+150+140-497-944-225+917-664-413-702 kem_460896pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair selected 524160 91624992 +71263+274035+0-112240+49968+150090-153783-35677+301185+11575-47374-15654-118698+120460-72937 kem_460896pcf_enc selected 188 79364 +3416+7892+0+8454+13267-3868-4376-4136+12800+7498-4217-8274-3598+15709-7828 kem_460896pcf_dec selected 188 252935 +17276+2588+581-120-17+1212+259-47-209-297+24-92+87-291+0 kem_460896pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pcf_keypair 0 524160 130880413 +207421-12297+0-26316+65873+34762-116039-21423+29321+134903+3687+172637-20225-60981-57623 kem_460896pcf_enc 0 188 90163 +1985+3758+79+34350-332-275+3378-644+59-463-603+0-520+4051-520 kem_460896pcf_dec 0 188 281808 +45694+3300+1473+158-722-1480-10+3877+2947+52-678+0-182-595-28 kem_460896pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair 1 524160 91725332 +98447-2165+111192+29547+99852-30664+98182+0-89684-35645-2684+131949-53576+92046-96047 kem_460896pcf_enc 1 188 79103 +6871-7555-7724+4197+8521+8307-3977+12481-3626+8481-8001-8507+3102+0-7765 kem_460896pcf_dec 1 188 253129 +16611+2437+642+780-92+520+0-220+1367+305-82-488-341-542-587 kem_460896pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pcf_keypair 2 524160 707697366 -102667+55341801-420402-602991+0-185989-763478-72142+595744+672115-34365+17142505+407129+270707+304280 kem_460896pcf_enc 2 188 203333 +11353-7391-7675+37103-131+21179-9316+225-332+16934-245+16957-703+25663+0 kem_460896pcf_dec 2 188 2288024 +41521+14511+6084+5568+143-1839-13471+982-918+394-2660-8451-2573-1473+0 kem_460896pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair 3 524160 404459517 +103210+13538+0-2405-24068+52649+103666-23458-158824-7147-21322-55688+75415+43287+38415 kem_460896pcf_enc 3 188 89749 +14442+3561+65110+18985+9353-10742-10110-10391+0+10454-5730-10271+19297-9903-10178 kem_460896pcf_dec 3 188 1489670 +36091+8821+5256+2238+0+1701-741-555-494-612-238-477-483+1347+154 kem_460896pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pcf_keypair 4 524160 705002496 +773115+866987+217048+864718-739145-875101-637668-480372-618632-328272+0-258427+664388+1102885+1099530 kem_460896pcf_enc 4 188 207909 +5639-5677+8490+33918-3550-13287+0-12865+24183-13426-13157+22881+13235+14050-13266 kem_460896pcf_dec 4 188 2311305 +34779+26217+16357-2514+20138-1253+0-1414-22776-35327+16933-16069-5222+4253+16229 kem_460896pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair 5 524160 506074466 -170728-249524+2306-214836+0-301829-73966-435382-130987+350462+1545132+1470230+1360763+1237671+1400039 kem_460896pcf_enc 5 188 103585 +22537+11490+576+27882+29305-393-229-325+28272+8850-36-205+0-213-312 kem_460896pcf_dec 5 188 1495778 +36721+10585+4735+1373+832+2252-256-836-582-814+0-8-429+1264-328 kem_348864 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair selected 261120 48224152 +102490+9996081-19506051-19437468+0+29118929+38920802-19429321+9816862-19467661-19567308+33714-19421423+29273876-9792863 kem_348864_enc selected 96 33854 +5753+0+1979-850-767-800-525+727-952-629-844+1609+5226+1009+2074 kem_348864_dec selected 96 115659 +15227+2155+418+452+221+86+0-246-13-82-242+40-25-123-89 kem_348864 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864_keypair 0 261120 49733522 +22809594+22893516-311899+11744794-11677302-11801304+0+11455457+11211069+69412146-11829096-11832793-272801+23014378-11731703 kem_348864_enc 0 96 42244 +5401+525-92+0-268+1112-2+1190-304-437+1273+4665-321-563+3250 kem_348864_dec 0 96 140847 +14798+1683+526+394+298+32-203+262-364-407-275-461-198+0-18 kem_348864 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair 1 261120 38455968 -9603887+127855-67511+29299373-9746760-9691538+19770002+146462+19577756-9728261-12849+0+118271+10003547-9676479 kem_348864_enc 1 96 33075 +4742+400+123-115-176-164+1394-236+2776+1-62+2342-150+0-32 kem_348864_dec 1 96 115570 +8315+2070+713+317-105-53-187-15+121+244+0+215-28-42-125 kem_348864 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864_keypair 2 261120 266373780 +99888542-74620-50294652+100076745+49877555+150098767+150268860-50239345-49802930+50132006-189415-50159407+0-13771+150157333 kem_348864_enc 2 96 104105 +5628+7374+3865-1595+7033+0-870-776-1222-1128-1622+2687-1272+2220+9809 kem_348864_dec 2 96 844443 +39178+9458+4896+2844+2467+0+1609-741+527-1765-1505-2031-4544-1795-378 kem_348864 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair 3 261120 200711481 +41609-61135114-141330-30660248-61143932+36895610+73509495-61196534+6004092-30661304+6370977+103835457-24328846+30450163+0 kem_348864_enc 3 96 38009 +7689+3127+11404+267+0-299-437-184-552+12361-531-637+8488-550+3594 kem_348864_dec 3 96 559588 +22800+6136+4267+1720+765-5+0+1111-248-336-223+79-155-129-46 kem_348864 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864_keypair 4 261120 303637038 +240069283-95892837-97062695-52629+65619+48137780+95754575+479531010-95843177+64858-48364102+0-95892321+48062544-95917650 kem_348864_enc 4 96 106270 +2671+9975-2730+3715-3491-3778-3428+7860+0-4256-3547-3712+8320+7964+4197 kem_348864_dec 4 96 864800 +38354+11369+3643+4558+508+0-137-531-1585-2282-1918+1255-3196+1335-1733 kem_348864 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair 5 261120 294115180 -127055777-126907379-126956698-127138964+221244660-95483371+133687+0+10024+31708258+284979190+221496777-95063627-63298139+158264783 kem_348864_enc 5 96 53563 +3753-721+2501+5152-4748+461+8198-551-4771-4836-4972-370+3875+0+3469 kem_348864_dec 5 96 564481 +27836+6703+3317+849+398-81-59-37+167+0-190-55-28+16-127 kem_348864f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair selected 261120 28981515 +6640-3428-15221-7056+5308-11142+12502-16559-16965+0-17408+7324+2116+29069+5112 kem_348864f_enc selected 96 33176 +4513+350+443+0+3886+1146+757-407-109-140-88+2440-268-59-119 kem_348864f_dec selected 96 115527 +10233+1992+809+97-209+0-189-128-359-260-63+91-200+51+1469 kem_348864f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864f_keypair 0 261120 40514403 -85865+117228-106342-44795-138518+1397+90946+0-92475-110825+7779+142744+7522+10677-14158 kem_348864f_enc 0 96 42245 +6051+248+0+61+1501-262+1518-295-158-121+2699+1717-62-90-133 kem_348864f_dec 0 96 141060 +12271+1518+448+485+275+85-239-149-126-40+0-387+117-1-133 kem_348864f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair 1 261120 28981982 +69602+24771+24651-30962+19372-33273-19940+11436+8699-5150+0-10482-9755-67045+1653 kem_348864f_enc 1 96 33342 +1928+1285+0-246-312+5461-347-302+1241-342-368-405+3622+946+2033 kem_348864f_dec 1 96 115582 +7958+1671+101-259-106+86+102+83+199-326+0-94-67-32-88 kem_348864f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864f_keypair 2 261120 227075900 -167049+152539+313035+0-155417-455228-88345+37123+222111-86838+54542-12769-111997+46901+190560 kem_348864f_enc 2 96 106648 +3010-969-2733-2603+1045+413+206-4280-4414-3732+7322+7783+0-3746+356 kem_348864f_dec 2 96 842927 +36906+10417+4447+1852+747-459+342+700+0-967-1041-147-1183-1490-1093 kem_348864f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair 3 261120 134410269 +79954-54919+60798+3159+0-37608-63665-62727+64644+138790+82845+59095-86144-22245-51281 kem_348864f_enc 3 96 43149 +9800+1718+4986-4694-5575+0-5200-1127+3822+20173-5739-1816+2776-1735+2761 kem_348864f_dec 3 96 559511 +19744+5497+3254+897-15+0-391-2-305+11-302+70-271-225+55 kem_348864f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864f_keypair 4 261120 214239532 +266654+177508+207316+285502+145398-239+0+62742+15507-93777-39825-161811-92552-136125-134339 kem_348864f_enc 4 96 114185 +2269-776-2285+1998+8730+4138-3624-3662+0+290-3867-3645+3989+3914-133 kem_348864f_dec 4 96 865950 +31540+8842+2381+901-850+2146+1009-3773-3008+0-2749-3706-2177-104+201 kem_348864f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair 5 261120 164267858 +174697+18987+120917+145259-19152+0-157034+43430-62923-3801+202472-111781-100205-5095+28683 kem_348864f_enc 5 96 49715 +7178+8288+0+8566-738+7897-892-645+3406-1102+3227-949+3433-542-1095 kem_348864f_dec 5 96 564861 +19874+5762+2695+1100+240+0+3-167-362-360-280-616+989-523-317 kem_348864pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair selected 261120 38582061 -16238+29354369-9843745+48680453+56158+29051148-9803345+2755-118571+9575667-9919328+58647908+0-9817329-301256 kem_348864pc_enc selected 128 40606 +2895+1719+108+4134-92-201+1316-347+0-103-111+1111-153-178+49 kem_348864pc_dec selected 128 122906 +9101+1924+707+37-33-148-119+26-39-301+0-89+157-86+24 kem_348864pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pc_keypair 0 261120 49757488 -11779454+34496135+57853676-78841+34548046-342086+11172550-11877886-282150+22961815-11864236+23057285-108549+0+11377067 kem_348864pc_enc 0 128 50888 +1052+2470-1493+324-1140-1292+2092+0-1795+6685+155-1272-1637-1349+408 kem_348864pc_dec 0 128 148692 +11755+1933+985+210-171+243+779-511-212-256+123-286-435-159+0 kem_348864pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair 1 261120 48377971 +105794+9636012-9794801+0-19729562+29050434-19574383+9660770-123243+19111450-103463-9760753+19429413+9745205-9969775 kem_348864pc_enc 1 128 41864 +789+151+1621-1520+1308-1250-1358-1280+2490+1020-1561+153-2+0-205 kem_348864pc_dec 1 128 122924 +7751+2307-34+126-284+0-359+155+89-54-91+209+179-39-162 kem_348864pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pc_keypair 2 261120 266449531 -332148+250245308+149945367-49830197+114051+0+49934067-50082838+99909898+500393658+49653202-59966-50234312-50258291-41367 kem_348864pc_enc 2 128 116162 +3849-806-2563+869+19-3697-4150+22370-4245+3494+3457-4498+202+0-183 kem_348864pc_dec 2 128 849112 +31998+9640+6662+3410+2252-153-1471+0-640+740+1356-1262-1820-1578-1828 kem_348864pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair 3 261120 231219258 -91584142-91750285+225747288+73571167+12264778+43116890+0+9135534+134303454-24814101+225597078-54753942-61179062-61112298-30546507 kem_348864pc_enc 3 128 45461 +14642+7221+10072+0-469+13086+4364-634-652-485-124-46+3685+3364-796 kem_348864pc_dec 3 128 567228 +21245+5969+3193+1453+371+0-251-489-224-283-178+725+155-750-530 kem_348864pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pc_keypair 4 261120 303689893 +220343-95977199+47978372-47962506+143851632-48006768-95886403+61271+48001185+0-96003243+47880238-47878653-48184719+335719628 kem_348864pc_enc 4 128 121870 +23324+5078-3681+4305-3844-3600+157-3474+0+7643-3483+4179+305-3730-3631 kem_348864pc_dec 4 128 868198 +38326+11251+5159+89+94+103+0-1041-1191-1140-2410-2470-1621-1437+1280 kem_348864pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair 5 261120 230344371 +71400+231516-31527504-31740937+284980888+63308916+0-63280019-63228063+159235+158525908-63245298-31559706+95153745-63208011 kem_348864pc_enc 5 128 56985 +20617+5169-103+5011+201+116+0-207+3982-111-403-137-352-263+12097 kem_348864pc_dec 5 128 573492 +21677+6219+2673+647+512+134+0-169-150-182-276-239+2951-86-16 kem_348864pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair selected 261120 28982022 +5424+17150+20275-493-11923-5097-63244+5741+9284-9308+27641+17742-6651+0-797 kem_348864pcf_enc selected 128 40728 +2135+354+1371+0-152+82-97-16-350+1160+2803-77+93-228-374 kem_348864pcf_dec selected 128 122848 +8988+2038+717+177-136-245+0-66-96-65+30-35+34-169+7 kem_348864pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pcf_keypair 0 261120 40495766 -86869-80638+116772-11084+41000+84682+27605+18046+0+23804-36237-12327-37533+77690-112026 kem_348864pcf_enc 0 128 50988 +1259-1357-1272+183+3673-1342+652+0+3352-1607-1565-1743-1594+217+3168 kem_348864pcf_dec 0 128 148682 +12085+2171+82+612-489+32-34-314-230+56+0+77-241-404-253 kem_348864pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair 1 261120 28975636 -8367+23591-42462+25164+20206+0+31059+50322-3420+12720-5557-15601+265-34493-3168 kem_348864pcf_enc 1 128 41005 +1717+0+806-456+3477+2464-781-552+712+2184-702-536+2119-537-792 kem_348864pcf_dec 1 128 122849 +7734+1834+934-3-11+1+145-37-167+0-100+93-167-23+364 kem_348864pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pcf_keypair 2 261120 227133570 -1138716+226483+62231+91865+237659+86051+181424-101912-88733-111783-298580+25113-75501-172719+0 kem_348864pcf_enc 2 128 112297 +5954+8333+5111+3570-135+4329+0+11266-255-694-623+391-700-176-346 kem_348864pcf_dec 2 128 849528 +35901+13395+4801+2022+1136-621+0-1092+163-881+1739-2292-168-2605-2716 kem_348864pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair 3 261120 134408504 +21360+107207-106158-34046+116924+148522-37930-41268-62287+0-43135+46701-21555+52049+23229 kem_348864pcf_enc 3 128 48755 +4211+16696+1072-3572-3050+5794-3726-3939-3966+22261+659-3361-4061+0+4186 kem_348864pcf_dec 3 128 566566 +21588+6776+3768+1460+684+21-243-336-272+47-418-171+0-182-128 kem_348864pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0; Copyright (C) 2019 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pcf_keypair 4 261120 214273701 +146899+14264-33764-7809+22713+15421+16531+85811-5512+89903-87890+0-160363-178581-187090 kem_348864pcf_enc 4 128 121909 +1615+4375+10033-3644+497+8658-2389-3460+4531-3778-3727-3922+101+0-4054 kem_348864pcf_dec 4 128 871827 +36365+11533+5495+2337+640-961-1385-388+0-606+2794+3792-734-1979-943 kem_348864pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; clang version 10.0.0-4ubuntu1 ; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair 5 261120 164317660 +78447+57159-8734+41042+60395-48387+0-77407+99872-55047+208204+94751-120873-71589-4929 kem_348864pcf_enc 5 128 60981 +10751+3128-3849+5383-4272-4153-4241+4102-4261-4411+8186+116-3218+166+0 kem_348864pcf_dec 5 128 573293 +20909+7212+3648+542+3+168-83-547-147-101-291+295+0-497-161 libmceliece-20230612/benchmarks/titan00000644000000000000000000044155314441554466016176 0ustar rootrootmceliece version 20230219 mceliece arch amd64 cpuid 756e6547 6c65746e 49656e69 65746e49 2952286c 6f655820 2952286e 55504320 2d334520 35373231 20337620 2e332040 48473035 0000007a 00000000 000306c3 02100800 7ffafbff bfebfbff 00000000 000027ab 00000000 9c000600 00000000 00000000 00000021 2c100800 00000007 00000000 00000000 00000000 00000000 cpucycles selected persecond 3500000000 cpucycles selected implementation amd64-pmc cpucycles selected 0 46 +24+20+27-1+0+0+0+0+0+0+0+0+0+0+0 randombytes selected 0 52 +434+95+1+1+1+2-1+0-1+0-1+9-3-3-1 randombytes selected 1 133 +346+50-8-1+2-1+1+6+0-1+0+11-1-2-3 randombytes selected 2 132 +28+4+0-3-1+1-1+5-1+6-2+14+0+4+0 randombytes selected 4 133 +4+3-4-2+1-1+0+5+4-3-1+11+0-1-2 randombytes selected 7 132 +28+4+0-1+0-2+5+5+0+6-1+13-1-1-1 randombytes selected 11 132 +10+4-2-1+2+0-1+0+0+0+0+12+2+0+0 randombytes selected 17 132 +9+4-2-1+0+3-1+8+0-1+1+13-2+1+0 randombytes selected 26 133 +4+3-4-2-1+0+4+7+5-1-1+13+4+0+0 randombytes selected 40 133 +8+3-3-1+1-2-2+4+1-2+2+6-2+0-2 randombytes selected 61 132 +5+4-2-1-1+0+0+7+0+1+2+7-4-3+2 randombytes selected 92 131 +6+5-1-1+0-2-1+2-3-3+0+8+0+1+1 randombytes selected 139 131 +6+5+3+0+0+2+0+6+0-1-1+15+0+1+0 randombytes selected 209 129 +8+7+2+2+0+0+0+5+0+0+0+9+0+0+0 randombytes selected 314 129 +8+7+1+2+2+0+0+4+0+0+0+9+0+0+0 randombytes selected 472 130 +7+6+0+1+1-1+2+5-1-1-1+8-1-1-1 randombytes selected 709 130 +7+6+0+2-1+2+0+4-1-1-1+8-1-1-1 randombytes selected 1064 130 +11+6+0+2+1+2+0+4-1-1-1+8-1-1-1 randombytes selected 1597 134 +7+2+17-2-3+17-5+0+16-4-5+3+15-4-5 randombytes selected 2396 154 +27+2-1-2-1+0-1+0-1+0-1+7-22+0+2 randombytes selected 3595 153 +32+3+0-1-1+0+0+7+0-1+2+7+0+2+0 randombytes selected 5393 154 +44+14+0-2-2-2-2+2-1+0-1+7-1+0+2 randombytes selected 8090 170 +8+18-3+7-7+0-14+3-14+0-14+7-14+1+9 randombytes selected 12136 188 +17+1-10+0-6+0-6+0-6+0-6+0-6+0-6 randombytes selected 18205 188 +3+9+1+0-6+0-6+0-6+0+1+0-6+0-6 randombytes selected 27308 189 -2+0+0-1+0+0-1-7-1-7+172+29-1+0+3 randombytes selected 40963 204 +0+7+0-3-8+4+1-5+7+3-7-2-8+0+1 randombytes selected 61445 202 +6+1+6-1-3+0-3+0-3+0-6+11+137+19+3 sort_int32 selected implementation avx2 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 selected 0 60 +2133+104-3-2-1+0-1+2+0-1+2+0-1+2+0 sort_int32 selected 1 60 +59+2+2-1+0-2+0-1+2+0-1+2+0-1+2 sort_int32 selected 2 61 +107+73+27+2+0+0+0+0+0+0+0+0+0+0+0 sort_int32 selected 4 73 +102+71+0-1-4-3+2-6+0+2-6+0+2-6+0 sort_int32 selected 7 110 +87+76+26+4+8+1+0+4-1-2-3-1-1-3-2 sort_int32 selected 11 168 +5673+99-2-2+0+1+0+0+0+0+0+0+0+0+0 sort_int32 selected 17 276 +316+75-1+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 selected 26 277 +16+2-4+0-1-4+0+0+1+0+0+0+0+0+0 sort_int32 selected 40 394 +2539+101+7+0-1+10+0-8+6-9-3-7+3-19+5 sort_int32 selected 61 401 +93+65+13+8+5+11+4+0-5-3-13-3-13-3-13 sort_int32 selected 92 787 +1702+297+22+13+14+0-14-27-29-34-7+7+2-12-27 sort_int32 selected 139 1581 +2383+320+120+112-45-25-21+0+133-32+13-47+3-3-26 sort_int32 selected 209 1764 +402+16+7-144-164-2+6-30-38+0+28+56-38-16+18 sort_int32 selected 314 2583 +2139+414+79-91-32-78+66+130-98-34-36+29+49-157+0 sort_int32 selected 472 3949 +1325+529-66-39+78-96-70-73-95+85+93+97+0-4+46 sort_int32 selected 709 6370 +2964+722+187+46+306+276-62-96-76-112+0-138-26-76+78 sort_int32 selected 1064 9992 +2427+618+204-11-51-100+50-179-67+2+36-36+0+2-66 sort_int32 selected 1597 14850 +2235+527+443+170+66+0-40+5+45-136-117-133-176-190-168 sort_int32 selected 2396 23224 +2960+924+415+446+366+406+186-6+0-90-86-95-59-139-62 sort_int32 selected 3595 36483 +2570+842+71+9-11-159-9-5-64+132+6+84-67-33+0 sort_int32 selected 5393 54150 +3910+874+492+306+148+320-6+228-242-252-78-180-8+0-214 sort_int32 selected 8090 90376 +3930+902+550+147+34+9+216+0-109-57-330-146-203-318-284 sort_int32 selected 12136 152871 +3372+758+282+0+101-203-109+82-45-12+145-581+117-89-594 sort_int32 0 implementation avx2 compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. sort_int32 0 0 57 +2145+76+31+1+2+0+0+0+0+0+0+0+0+0+0 sort_int32 0 1 58 +68-1+0-2+2+0+0+1-1+0+0-1-1-1-1 sort_int32 0 2 62 +128+52+23+9+1+2+1-2+0-1+0-1+0-1+0 sort_int32 0 4 90 +1180+46+23+3-2+1-2+1-2-1+0+1-2-1+0 sort_int32 0 7 157 +47+53+68-4+0-2+0-2+0-2+0-2+0-2+0 sort_int32 0 11 167 +1407+47+28+0+0+1+0+0+0+0+0+0+0+0+0 sort_int32 0 17 284 +336+104-6-6+0-6+0-6+0-6+0-6+0-6+0 sort_int32 0 26 280 +29+11+1-1+5-2+0+0+0+0+0+0+0+0+0 sort_int32 0 40 394 +2184+124+27-1+0+0+0+0+0+8-2-2-2-2-2 sort_int32 0 61 408 +69+38-8+1-2-6+2-3+0+0+0+0+0+0+0 sort_int32 0 92 789 +1528+266+42+7+4-14+0-10+0-10+0-10+0-10+0 sort_int32 0 139 1575 +1732+257+10+3-15-15-6-8-1+20-8+5+18+0-5 sort_int32 0 209 1593 +659+78+10-14-8-12+1-14+0-14+0-14+0-1+3 sort_int32 0 314 2576 +2532+294-14+25-24-31+12+37-52-45-21+48+76-99+0 sort_int32 0 472 3900 +1207+390+126+104+22+0-46-18+49-21-54-66-29+42-67 sort_int32 0 709 6519 +3318+1254+287+108-9+68-25-13+0+4+4-38-19-12-69 sort_int32 0 1064 9720 +3294+939+361+90-18+0+80+80+46-32-43-81-24-36-67 sort_int32 0 1597 15345 +2188+480+187+217-37+83-15+27+46-34-77-183-71-288+0 sort_int32 0 2396 25328 +3194+1622+620+130-81-533+56+46+0-4-108+14-32-64-48 sort_int32 0 3595 38731 +3290+1619+1413+46+0+556+166-387-334-486-323+367-449-313-480 sort_int32 0 5393 59746 +4484+3413+629+318+74+88+0-316-232-106+302-336-156-452-176 sort_int32 0 8090 98681 +3798+1124+547+182+461-159-75+128-68-234+0-324-40-178+18 sort_int32 0 12136 159709 +4457+1238+1509+669+125+30-57+196-187-97+0-65-109-116-271 sort_int32 1 implementation avx2 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 1 0 60 +298+62+59+5+0+1+1+0+0+0+0+0+0+0+0 sort_int32 1 1 60 +89-2-3+4-1+5+0-1+0+0+0+0+0+0+0 sort_int32 1 2 61 +82+67+46+35+0+0+1+3+0+0+0+0+0+0+0 sort_int32 1 4 73 +90+72+20+0+2+0+2-6+0+2-6+0+2-6+0 sort_int32 1 7 113 +107+22+1+5+1+0+1+0-3+2-2-4-5-6-4 sort_int32 1 11 168 +262+120-4-2+0+0+0+0+0+0+0+0+0+0+0 sort_int32 1 17 276 +230+42+11-4-3+0+0+0+0+0+0+0+0+0+0 sort_int32 1 26 277 +54+0+1+5-2-4-3+0+1+0+0+0+0+0+0 sort_int32 1 40 399 +742+33+4+6+3+3-2+0-5+1-20-6-20-6-20 sort_int32 1 61 404 +108+63+8+0-1+5+0-11-4-14-17-13-4+0+2 sort_int32 1 92 778 +778+215+59+7+20+0+0-5+1-3-3-9-2-7-11 sort_int32 1 139 1565 +1126+359+21+247-28-10+78-11+23-30-15+149+0-51-6 sort_int32 1 209 1587 +544+173-59+130+103+163+170-57-18-10-17+147+0-17-58 sort_int32 1 314 2614 +1213+230+202-33+10-133-86-34-183+20+30+76-15-212+0 sort_int32 1 472 3969 +1255+403+19-66+79+32-109+43+0-80-173+74-30-10+0 sort_int32 1 709 6326 +1792+233-211+127+98-21+108-68-32-80+0+40+4+0-68 sort_int32 1 1064 9878 +1652+353+271+9-64-93-133+3-68-8+6+0-104-8+6 sort_int32 1 1597 14732 +2066+433+477+85+88+0-9-109-77-165+18-22-53-229+39 sort_int32 1 2396 23284 +2436+328+474+344-18+94-30-40-150+0-166-104-78+204+108 sort_int32 1 3595 36471 +2241+600+100-167-277+0+155+29-28+8-222-16-46+14-277 sort_int32 1 5393 54276 +3274+900+500+470+288+252-366-102-282+0-242-46+4-516-140 sort_int32 1 8090 90337 +2627+487+105-26+150+138-150-34-184+0-95+15-37-119+57 sort_int32 1 12136 152864 +1595+986+0-103-233-180-265+322+636+429-873-346-377+2301+8 sort_int32 2 implementation portable4 compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. sort_int32 2 0 50 +867+69+31+28+27+2+0+0+0+0+0+0+0+0+0 sort_int32 2 1 53 +60+25+0-4+0-4+0-4+0-4+0-4+0-4+0 sort_int32 2 2 65 +377+93+2+3-1-1-1-1+0+0+0+0+0+0+0 sort_int32 2 4 105 +245+223+99+64+21-1+0-4+3-3-2-4+3-3-2 sort_int32 2 7 187 +586+338+59+1+0-4+0-4+0-4+0-4+0-4+0 sort_int32 2 11 326 +906+280+74+3+1+0+0+0+0+0+0+0+0+0+0 sort_int32 2 17 568 +1377+740+194+67+65-4-3-4-3+0+0+0+0+0+0 sort_int32 2 26 1037 +1370+587+291+96+93+94+30+0-46-50-49-50-49-48-50 sort_int32 2 40 1774 +1704+490+153+66+6-2+3+0-10+0-10+0-10+0-10 sort_int32 2 61 3102 +2309+1047+420+146+47-16+3-4-3-1+0+5-3-12-4 sort_int32 2 92 5671 +2795+983+422+57+16+23+0+2-41-54-58-41-53-72-51 sort_int32 2 139 10066 +3894+1570+703+490+217+4+19+0-1-37-11-40-74-107-130 sort_int32 2 209 17725 +3407+1524+906+439+277+175+0+44-154-165-149-152-171-205-204 sort_int32 2 314 30527 +3752+1723+985+408+215+56-145-62-103+0+39-79-112-119-141 sort_int32 2 472 50983 +1790+817+569+476+131+122-60+68-88+0-83-135-137-224-92 sort_int32 2 709 88728 +4614+1918+1430+661+344+369+0-22+323-180-275-99-288-373-345 sort_int32 2 1064 147403 +4009+1770+544+317+38-12+478-40-7+0-317-396-42+212-602 sort_int32 2 1597 251098 +1987+1311+699+1253+439+63+0-14-304-38+262-339-232-121-161 sort_int32 2 2396 424763 +2347+1344+1251+636+155+1414+1839-522+0-687-770-478-1267-1108-911 sort_int32 2 3595 707183 +17387-286-569+0+488-509-1158+969-916+4088+539-925+991+246-592 sort_int32 2 5393 1215388 +3442+2635+775-335+0+1042-1320-857-599+416+374-133-1+1546-336 sort_int32 2 8090 2007965 +1234+1160-1015+2736-36+119+1060-1671+859-629+1209-416+0-476-1339 sort_int32 2 12136 3517537 +2872+1204+712-512+1033+3032+1993-717+3716+0-557-1198-1123-1781-2145 sort_int32 3 implementation portable4 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 3 0 52 +835+63+45+42+17-2+0-2+0-2+0-2+0-2+0 sort_int32 3 1 51 +34+49+1+0+1+0+2+6+0-2-3-2-2-2-2 sort_int32 3 2 74 +736+75+2+2+2+2+2-5-3-1+0-2-3-2-3 sort_int32 3 4 122 +491+68+22-3+1-1+0+3+0-1+0+3+0-1+0 sort_int32 3 7 213 +696+218+30+3+0-1+0-1+0-1+0-1+0-1+0 sort_int32 3 11 376 +917+323+2-2-3+0-4+0-4+0-4+0-4+0-4 sort_int32 3 17 606 +1496+837+179+6+3+2-2+0+0-7-3-2-4-2-3 sort_int32 3 26 1018 +1988+665+294+51+0+0+0+0+0+0+0+0+0+0+0 sort_int32 3 40 1820 +2084+876+322+85+7-4-4-5+0+2-2-5-5+2+0 sort_int32 3 61 3015 +2300+718+109+20+7+0-8-5+0-8-5+0-7-6+0 sort_int32 3 92 5343 +2902+1063+291+114+40-14+48-6-20-6+11-12-8-24+0 sort_int32 3 139 9430 +4072+1596+620+255+189+54+68-10+0-13-87-68-68-74-72 sort_int32 3 209 15970 +3849+2434+758+269+107+0-28-22-88-14-50-29+1-39+9 sort_int32 3 314 27552 +4152+1320+325+161+47+59+36-2-21-20-70+0-52-46-62 sort_int32 3 472 46111 +2341+906+329+75+127+0+4-164-4-50-156+28-120-38-173 sort_int32 3 709 80242 +5166+1918+374+194+153+171+0-23+28-104-119-90-69-185-3 sort_int32 3 1064 133335 +4456+1768+819+442+205+117+71+0-54-126-45-169-247-135-187 sort_int32 3 1597 228660 +2234+790+170+13+256+77-200-236-234-220-26-238+0-78+30 sort_int32 3 2396 386420 +2626+2189+621+686+315+211-530-154-181-396-135-474-70+323+0 sort_int32 3 3595 644885 +3179+1799+849+315+235-38+0+123-271+97-137-239-275-339-35 sort_int32 3 5393 1118599 +4529+1895+3668+577+648-595+29-191+0-20-932-994+4-100-978 sort_int32 3 8090 1847659 +1387+1574+613-2255+1193-21+962+1054-786-1986-379-774+0+699-1250 sort_int32 3 12136 3246322 +2552+356-799+1724+2165+1130+53-1-456-2344-1581+1356+0-90-2238 sort_int32 4 implementation portable4 compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. sort_int32 4 0 50 +603+65+27+2+0+0+0+0+0+0+0+0+0+0+0 sort_int32 4 1 51 +56+35-1-1-1+0+1-2+2-2+2-2+2-2+2 sort_int32 4 2 66 +390+135+5+2+0+1+0+0+0+2-1+0+0+2-1 sort_int32 4 4 107 +361+108+27-1+0-3-1-3+0-1+0-2+1+1+1 sort_int32 4 7 188 +481+246+15-3-2+1+0+0+0-3+2+1+0+0+0 sort_int32 4 11 329 +845+395+112+0+0+0+0+0+0+0+0+0+0+0+0 sort_int32 4 17 566 +1386+677+267+94+35+11+1+0+0+0+0+0+0+0+0 sort_int32 4 26 1050 +1531+637+229+128+107+88+58+0-44-53-52-51-52-53-52 sort_int32 4 40 1815 +1989+758+418+174+82+13-9-10+0-2+0-2+0-2+0 sort_int32 4 61 3224 +1754+886+139+5+8-1+0+2-3+25+0-15-72-66-70 sort_int32 4 92 5822 +2546+1144+489+216+119+127+72+0-29-81-87-81-87-81-49 sort_int32 4 139 10385 +3585+1519+570+310+207+0+8+2-31-63-140-176-146-131-158 sort_int32 4 209 17955 +3415+1487+871+674+459+217+124-22-80+0-38-105-129-64-184 sort_int32 4 314 31271 +3664+1801+785+470+212+3+43+0-110-174-179-326-238-192-185 sort_int32 4 472 52384 +1519+726+156+0+19+51-102+17-144+0+1-146-157-178-77 sort_int32 4 709 90621 +4275+1844+938+1026+454+197+18+0-203-417-464-572-426-358-637 sort_int32 4 1064 149503 +3384+2045+1116+987+129+0-207-111+278+24-129-155-434-181-549 sort_int32 4 1597 254548 +1514+1313+734+480+371-155-175-98+46+249-327-123+0-382-22 sort_int32 4 2396 429261 +2680+2106+1558+837+442+43+890-417-94-429+0-711-374-561-279 sort_int32 4 3595 715209 +3145+727+871-205+169+0+432-661+387-333-565-261-1059+181-813 sort_int32 4 5393 1226583 +4888+2323+1022+249+484-473+42+0-832+1104-1081-707-1578-1190-1647 sort_int32 4 8090 2024061 +2529+1248+1720+1606-642+699+0-994-598+1039+143-1922-1579-1274-248 sort_int32 4 12136 3543827 +4399+625+396-24+0+1095-376-476+703+1220-1503-1251+637-118-2471 sort_int32 5 implementation portable4 compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin sort_int32 5 0 51 +1509+48+16-3-1+0-1+0-1+0-1+0-1+0-1 sort_int32 5 1 50 +49-4+2-4+29-2+0+0+0+0+0+0+0+0+0 sort_int32 5 2 67 +640+103+5+5+3+0+0+0+0+0+0+0+0+0+0 sort_int32 5 4 108 +365+174+29+23+1+2+0+0+0+0+0+0+0+0+0 sort_int32 5 7 200 +581+273+10+2-1+1+0-1+0+1+0-1+0+1+0 sort_int32 5 11 350 +896+322+11+1-1-3+0-2+0-2+0-2+0-2+0 sort_int32 5 17 573 +1424+621+96+4-2+3-1-1+0-1-1+0-1-1+0 sort_int32 5 26 983 +1684+757+147+123+0-8-5-1+0+1-7+0-5-1-5 sort_int32 5 40 1775 +2113+905+328+161-2+0+16+0+3-15-29-22-32-24-32 sort_int32 5 61 3068 +2544+565+93+50+62+40+32-29-5-1+0-16-4-21+0 sort_int32 5 92 5568 +2915+1083+489+200+108+18+22+0-2-16-38-49-52-47-21 sort_int32 5 139 9649 +4274+1914+684+260+128+100+30+0-52-88-99-46-80-100-78 sort_int32 5 209 16878 +4316+1891+879+439+222+249+0+73-112-120-162-127-210-250-231 sort_int32 5 314 29470 +4418+2036+1034+526+34+172+0+16-178-288-399-459-449-287-411 sort_int32 5 472 49309 +1920+1088+570+157+34+86+116-39-140+0-243-207-199-235-378 sort_int32 5 709 85917 +5658+2420+1249+1050+338+73+0+272-268-347-417-175-325-233-332 sort_int32 5 1064 142830 +5206+2916+1435+957+450+191+192+0-149-279-178-108-426-304-182 sort_int32 5 1597 244010 +2100+1637+1077+776+276+330-1052-960-146+80-93-21+0-1268-1346 sort_int32 5 2396 415770 +3304+1662+737+751+349+225-492-836+712+0-123-504-488-295-447 sort_int32 5 3595 690771 +3974+1979+1482+875+410+347+0-162+24-484-658-816-653-752-947 sort_int32 5 5393 1187311 +5843+1749+763+601+430+0-204+516-330-144-414+640-594-104-120 sort_int32 5 8090 1949940 +5366+3907+622-131+629+0-952-1459-278-260-734+3102+1756-655+722 sort_int32 5 12136 3418524 +2369+455+391-491-1666+515-1365+0-1028+489+1227-2831-2087+1197-689 xof_shake256 selected implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 selected 0 1754 +4251+231+84+0+19-1+4+8+7-7-1-11-4-4-4 xof_shake256 selected 1 1757 +366+61+6-3-6+2+0+0-5+6-6+6-6+6-6 xof_shake256 selected 2 1764 +291+55+2+13+3-8-1-14+0-14+0-14+0-14+0 xof_shake256 selected 4 1764 +263+22-2-25-11-23-11-5-7+0+0+0+0+0+0 xof_shake256 selected 7 1764 +171+18-5-17+1-4+9-9+0+0+0+0+0+0+0 xof_shake256 selected 11 1756 +299+69+79+0-9+1-9-7+6-9-9+1+0-21-9 xof_shake256 selected 17 1752 +340+66-1-15+0-3+32-18-2+1+17-18+7+17-18 xof_shake256 selected 26 1752 +203+21+10+10+0+0+15+1-5+0-2+1-5+0-2 xof_shake256 selected 40 1763 +360+122+3-7-4-10-6-15+4+0+4+0+4+0+4 xof_shake256 selected 61 1750 +307+6+3-3+13-5+0-1+5+0-1+5+0-1+5 xof_shake256 selected 92 1756 +309+34+1-2+0-12+2-22-15-6-11+2+6+3-1 xof_shake256 selected 139 3295 +443+58+3+0-17+10-15-21+0-10-15+5-10+3-15 xof_shake256 selected 209 3292 +333+11+7-7+3-7-4+4+0-4+4+0-4+4+0 xof_shake256 selected 314 4832 +418+59+14-1+9-14+0+0+0+0+0+0+0+0+0 xof_shake256 selected 472 6377 +282+87+29+39+29-3-14-18+5-14-16-13+11+0-16 xof_shake256 selected 709 9488 +330+101+34-18+4+2-15-15-29+31+2-18+0-14-17 xof_shake256 selected 1064 12554 +434+34+62+1+25+17-3-11-3-11-3-11-32+16+0 xof_shake256 selected 1597 18788 +275-28-70-54-26+0+0+2+0+0+2+0+0+0+0 xof_shake256 selected 2396 28066 +277+63-3+34+0+0+2+0+28+0+0+0+0+2+0 xof_shake256 selected 3595 41947 +319+46+13+6-71+51-54+0-49+51-40-1-4+51-40 xof_shake256 selected 5393 62001 +235+93+111-51+24-28-58+22+0+9-42+0-89-28-22 xof_shake256 selected 8090 92839 +371+94+0+21+848+143+79-22-17-17-13+28-1-4-26 xof_shake256 selected 12136 139104 +361+45+50+30-13-8+0-8+0-8+0-8-28+8-28 xof_shake256 selected 18205 206794 +439+95+77+77-13+43+69+0-31-10-10-13-32+4-26 xof_shake256 selected 27308 310103 +364+129+13-107-83+22+6-142+6-139-252-140-91+20+0 xof_shake256 selected 40963 467104 +69+73-48+838+33+92-160-31+19+0-36+9-43-52-36 xof_shake256 selected 61445 698754 +344+171-120-114-16-16-23+111-166-67+1029+209+60+0+114 xof_shake256 selected -1 1618 +348+90+8-1-2+9-16+0+0+0+14-4-11-4+8 xof_shake256 selected -2 1622 +274+75+18-11-1+9+13+1-8-11-13+0-11-13+0 xof_shake256 selected -4 1631 +238+71+12-8-3+2-1+6-7+2+0-13+2+0-13 xof_shake256 selected -7 1644 +242+32+24+21+20-2+5+1-15-1+0-4-7-1+0 xof_shake256 selected -11 1660 +244-1+0+1-11-3+6+7+1+5-14-3+0+0+0 xof_shake256 selected -17 1691 +220+64+57-5-10-5+1+3+13+0-4+0-4+0-4 xof_shake256 selected -26 1742 +265+42-4-7-22-16+1+4-23-22+0+0+0+0+0 xof_shake256 selected -40 1815 +255+49-17-6+9-1+10+11+0-8+0-8+0-8+0 xof_shake256 selected -61 1916 +241+15+1-12+0-9+8+0-13-2-5+2-2+2-2 xof_shake256 selected -92 2058 +221+7+3+0-5-5+14+11+12+0+0+0+0+0+0 xof_shake256 selected -139 3140 +1685+179+23+1+2-16+0+0-6-6-6-6-5-9+0 xof_shake256 selected -209 3486 +284+67+36+50+14-2+4-4+12-10-11+0-3-10-4 xof_shake256 selected -314 4862 +318+55+87+2-9-8-11+0-18-9-22+14+4+5-11 xof_shake256 selected -472 6520 +338+64+8+10-2+8+0+4-2+5-27-15-37-18-31 xof_shake256 selected -709 9357 +334+57+18-28+26+0-37-26-24+26+15-13-3-13+49 xof_shake256 selected -1064 12838 +332+34-5+37-12+15-23+0-20+6-62+3-49-12+17 xof_shake256 selected -1597 18840 +347+71+6+67-2+0+14+0-6+0-6+0-6+0-6 xof_shake256 selected -2396 27886 +310+20+52-12+37+63+40-22-28-7+0-30-1+13-20 xof_shake256 selected -3595 41466 +305+63+120-87-33-21-27+17+54+9+0+11-79-57-41 xof_shake256 selected -5393 61338 +264+197+15-67+11+23-37+54-8-1+37-16-9-59+0 xof_shake256 selected -8090 91621 +207+64-48-5-69+34+0+34+0+34+0+34+0+34+0 xof_shake256 selected -12136 136915 +366+0+66-103+74+16+27+59+106-162-125-47-75-80-4 xof_shake256 selected -18205 204064 +292-6-41-131-32-39-206+23-39+46+23+102+903+91+0 xof_shake256 selected -27308 305647 +386+192+71-100-27+125-11+0+6-113-54+12-109-161+127 xof_shake256 selected -40963 458524 +278-27+142+2-103-62-228-49+42+0+15-162+31+283-97 xof_shake256 selected -61445 686478 +657-117-114+60-102-134+112+226+0-36-102+8+160+226+0 xof_shake256 0 implementation tweet compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 0 0 16218 +2952+744+230+234+127+43-39-7+0+14-22-110-84-58-120 xof_shake256 0 1 16334 +256+89-10+0-3+137+26+60-73+47-54+84-79-53-94 xof_shake256 0 2 16287 +387+228+79+125+27-47+101+0-64-75-108+28-3-48-38 xof_shake256 0 4 16252 +136+43-56-32+13-67+0-82-43+3+0+44+33-5-40 xof_shake256 0 7 16224 +347-45+126+0+104-190+86-42+32-48+90-56+32-152-40 xof_shake256 0 11 16263 +243+0+67-75+19-130+0-35+131-65-43+39+988+119-58 xof_shake256 0 17 16199 +282+108+13-111+23-184+60+123-67-139-163+0-14+69-7 xof_shake256 0 26 16212 +15+51+0-44+96+43-23+96+14-4-32-35+85-24-114 xof_shake256 0 40 16002 +544+203+20-2-78-30+10-68-100+46+86+0-172-92+48 xof_shake256 0 61 16274 +164+73+78+0-48+14-6+14-82-107-75+56+81-39-66 xof_shake256 0 92 16062 +251+13-44-72-48-102+16+8+24+76+0-86-128-185+47 xof_shake256 0 139 31572 +466-265-162-64-70+45-25+54+98-2+194+0-132+28+60 xof_shake256 0 209 31998 +408+119-64-18+208-14-162-55-209-176+46+34+0+58+26 xof_shake256 0 314 47774 -55-61+50+235+130-237+0-26+366-14+314+191-134-11+20 xof_shake256 0 472 63594 +528+68+252-22+236+134-342-76+348-344+58-8-122-8+0 xof_shake256 0 709 95094 +290-192+6+168-72+128+0+52+314+90-14-56-242-44-272 xof_shake256 0 1064 126558 +390-262-42-256-32-138+460+284+86+0-230-520+2+252+290 xof_shake256 0 1597 188848 +751+987+580+758+1052+456+1096+0-2492-2270-2046-2034-2554-1676-2150 xof_shake256 0 2396 280084 +126-619-336-402+128+196+320-628-274+126+340+0-50-1120+194 xof_shake256 0 3595 419704 +3651+111+716-670+154-178+498+518-256+0-706-192-582-12+16 xof_shake256 0 5393 622170 +9794+6469-996-640-476+0-278-1350-1030+1339-70+734+418+292+292 xof_shake256 0 8090 933484 +11085+12133+12052+10026-452-1456+0-1516+266-1400+7832+4996-2842-1710-2014 xof_shake256 0 12136 1394394 +3030+2329+2944+1676+3824+1916+660-1590-569-1646-1346-112+0-1268-1386 xof_shake256 0 18205 2077342 +2509-598-1010+653-177+865+2011-1366+196-439-2264-859+0+17537+20811 xof_shake256 0 27308 3116834 +34983-1037+18046+26156-2807-364-1489+40962+31464-148-1396+20760+609-1340+0 xof_shake256 0 40963 4686097 +2814-3846+0-2913-2299+3393+35868-615+5183+18823-478+4780+4239-15071-1557 xof_shake256 0 61445 7017889 +25556+4354-20927+21743-20456+35240+6526-5155-2248+0-10009+23070-13967+75335-12511 xof_shake256 0 -1 16216 +147-109-66-72-57+52+151+126+17+0-95+18-18-186+82 xof_shake256 0 -2 16220 +324+110-149-32-99+21-35+49+83-58-166+0+94-74+140 xof_shake256 0 -4 16063 +284+56+220+247+51-64+67-116+0-193-142-11+3-125-97 xof_shake256 0 -7 15977 +23-21-65+113+4+0+107-5+14+28-139-138-36+115-35 xof_shake256 0 -11 16003 +413+157-88+0-43+16+21+23-81-16-7+77-80-112+42 xof_shake256 0 -17 15997 +141-22+0-4+102+37+24-55-95+3-101-147-51+49+209 xof_shake256 0 -26 16198 +290+94+12-33-66+82+34+0-108-74-36-74+23+60-62 xof_shake256 0 -40 16255 +260+112+10+10+73+87+115-18+0-25-73-87-10-2-55 xof_shake256 0 -61 16337 +56-32+59+25-41-155-143-133-87-68+0+9+47+39+32 xof_shake256 0 -92 16237 +200+226+200+152+285+250+0+39-211-211-288-269-162-243-230 xof_shake256 0 -139 31736 -47+84-250-157+23-27-98+9+65-373+44-228+38+0+202 xof_shake256 0 -209 32106 +282+0+100-101+238+63-275-1-62-59+85+26+2-109-104 xof_shake256 0 -314 47405 +488-97-26-160+340+9+0+257-41+256-212-178-292+121+143 xof_shake256 0 -472 63919 +503-96+150-69-34+253+56+158-107-72+0-140+71+13-8 xof_shake256 0 -709 94314 +2180+1894+1685+1144+0-131-145-68-358-246+43-416+20-108+75 xof_shake256 0 -1064 127370 +709+115-63-180+451+336-406-376+350+0-321-114+2+120-64 xof_shake256 0 -1597 190471 +0-14+13+23-369+101-341-397-279+621+317+75-261-318+211 xof_shake256 0 -2396 281689 -146-380+443+11+53+269+141+0-88-189-71+363-350-21+756 xof_shake256 0 -3595 422024 +712+113+0-66+118+766+544-166-172-14+1289-163+115-838-88 xof_shake256 0 -5393 625111 +8613+2854-235-699+1087-191+833+687+0-419+403-275-221+307-53 xof_shake256 0 -8090 949644 +675+935+96+1375-3+618+0+379-407+1445-1682-12121-12688-12375-12008 xof_shake256 0 -12136 1407154 +20355+19747+9273+250-2172-30+0-1454-1024-497+851+415-1688-1248+1730 xof_shake256 0 -18205 2093515 +0-402+2538+116+582-193-886-345+352-386+563-2105+85-520+716 xof_shake256 0 -27308 3140097 -2353+431+1066+0+1538-235-1157-39+5205-21+1643-3323-2013+6693+4747 xof_shake256 0 -40963 4719253 +63341+4368-806+0-7487-7280-5404-15+2578+7192-3819-327+14038+18751+7384 xof_shake256 0 -61445 7068399 -1119+0-6652+22047+25480+21354+2827+13843-13931-5750-8280+6000-9530+25832-6116 xof_shake256 1 implementation tweet compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 1 0 8080 +3101+978+336+36-26-17+0-15-20-37-23+41+10-34+10 xof_shake256 1 1 8087 +236+46+14+23+9-5+0-45-36-97+0+68+9-9-59 xof_shake256 1 2 8069 +198+85-28-34+20-28-3-39+5+11+37-10+68-6+0 xof_shake256 1 4 8075 +192+140-10-27+0-75+80-28+45+2+41+39-7-27+0 xof_shake256 1 7 8063 +172+97+25-34+32-38-18-34+7+0-39-38+139+68-39 xof_shake256 1 11 8070 +178+85-33-3+32-25+26-37-27-37+60+0+21-9+20 xof_shake256 1 17 8061 +279+30+98+17+16-44+59-43-4-42+70-16+0-14-5 xof_shake256 1 26 8087 +199+94-13+45+0-39-5-11+7-11+11-39-5+53+31 xof_shake256 1 40 8076 +239+36-20-27-13-38+0+44-9+25+151+25+0+44-33 xof_shake256 1 61 8084 +262+56+2+6+12-40+0-36+12-36-28-40-16-36+104 xof_shake256 1 92 8075 +262+77-16-36+21-27+21-31+57-6+0-6+0-10+2 xof_shake256 1 139 15885 +238-4-73-41+5+28+35+19+25-81+22-14+0-59-79 xof_shake256 1 209 15873 +269+0+19-62+177+85-15-34+0-19-6-8+9-45+98 xof_shake256 1 314 23679 +267-75+174-43+12+131+0+32-2+102-5+64-37-79-3 xof_shake256 1 472 31453 +244+100-56+14+71+2-85+66-8+0-8-3-88+25-11 xof_shake256 1 709 47066 +201+207+0+88-15-2-131+5+72-126-48+8-187+40-71 xof_shake256 1 1064 62687 +306+0-183-243+199+82-100+120+90-89-95-44+37-123+27 xof_shake256 1 1597 93873 +330+20+65+37+19-245-188+22+105-126-80+0-216-151-65 xof_shake256 1 2396 140509 +363+83+169+14+0-61+494-116+89-93-67-38-81+633-54 xof_shake256 1 3595 210543 +266-35-15+188+699-8-57+153-3+320+0+52+402-35-94 xof_shake256 1 5393 311520 +391-11-155+322+97-82-15+15-5+757+0-19+353+73-237 xof_shake256 1 8090 467214 +520+0-69+267+487-302-123+1286+102-63-138-3+88+784-184 xof_shake256 1 12136 700487 +457+229-93+642+1114-58-65-292+227+7-212+256-181-372+0 xof_shake256 1 18205 1043207 +297+218-518+96-211-461-484+1038+380+103-396+0-329-512+1813 xof_shake256 1 27308 1564648 +342-1080+1304+809-644-118-1035+312+131+1660-410-931+0-449+1646 xof_shake256 1 40963 2351140 +1038+545-506-765-978+170+378-1076-477-988+226+0+732+1740-559 xof_shake256 1 61445 3518978 +1101-126-620-133+247+363+0-388-737+942-1084-1529+568+548+742 xof_shake256 1 -1 8035 +386+156+9-15-15+56-21+3-25+3-21+0+27-60+0 xof_shake256 1 -2 8041 +118+39-73+42-27+0-72-5-2-45+68+11-1+4+29 xof_shake256 1 -4 8046 +92-73+22+29-51-88-92+1+14+0-2+4+0-2+4 xof_shake256 1 -7 8021 +84-4-79-59-14+28-59+31-63+0+41+57+26-6+28 xof_shake256 1 -11 8059 +12+30-75-3+15+33+22+15-26-45-35+28-4-72+0 xof_shake256 1 -17 8065 +196+7-1+50+0-2-76-22+53-76-48-84+3+24+11 xof_shake256 1 -26 8091 +206+34+40-68-21-90-23-15+11-15+0-44+5+51+12 xof_shake256 1 -40 8071 +247+61-5+20-14+62+0+52-49-9+0+52-17+116-2 xof_shake256 1 -61 8131 +127+70-105-18+0-13+21-89+43+0+13+10-6+14-93 xof_shake256 1 -92 8134 +112+55+0+19-36-4-4-4-4-4+58+53-6+90+69 xof_shake256 1 -139 15990 +195+114-33+30+130+34+55-2-25+0+37-4-14-65-56 xof_shake256 1 -209 16203 +39-9-84+22-118-132+10+0-67+8+0-67+10+0-67 xof_shake256 1 -314 24045 +200+0-48-4+82+54-60-93+140-15+11-37+95+91-46 xof_shake256 1 -472 32041 +253-1+89+0-111-79-65+8+14+112+26-49+33-62-37 xof_shake256 1 -709 47922 +264-36-38+0-5+108-99-82-43+42+89+3+86-79+14 xof_shake256 1 -1064 64017 +123-24+54-22+92-4+16-71+1029+0-1+18-77-180+54 xof_shake256 1 -1597 95830 +114-28+55+64-34+0-12-172+89+57-44-84+245+46-11 xof_shake256 1 -2396 143667 -171+446+30-86-73+37-61+94-66-103+0-62+74+45+101 xof_shake256 1 -3595 215180 -35-171+158+20+75-421-327+76-117+40-325+131-204+211+0 xof_shake256 1 -5393 318747 -30-178-18-318-48-84-113+18+0+103+18+0+103+18+0 xof_shake256 1 -8090 477905 +302+1034-459+90+231+151-790-291-157+0+85-152+415-92-167 xof_shake256 1 -12136 716616 +806+543+209-508+826-473-217-79+212+529-114-64+227+0-129 xof_shake256 1 -18205 1067213 +81-936-167+96+143-655-21+0+1123-305-672-1426+689+166+107 xof_shake256 1 -27308 1600396 +513-227+175+1079-129+896-573+776+359-566+0+1521-722-222-201 xof_shake256 1 -40963 2404324 +415+0-803+283-681-174+1247+459+264+151-1415-986-1456-1034+981 xof_shake256 1 -61445 3598368 -616-2128+0+1344-257-1554+721+619+286+786+809-264-569+28-314 xof_shake256 2 implementation tweet compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 2 0 16231 +4548+782+181+4-2+67+63+4-43-5-4+0-32-59-32 xof_shake256 2 1 16618 +191+120+125-44+0+95-43+6-110+54-21-21-13-67+13 xof_shake256 2 2 16591 +235+139-102+0+42+53+31-99-68-15-22+89-38-94+55 xof_shake256 2 4 16336 +370-146-6-46-68+0+104-35-49+87+178-39+50+68+35 xof_shake256 2 7 16594 +280+124+30+83-98-135-2-69-113+0+1-39+48-10+13 xof_shake256 2 11 16437 +415+250+93+171+228+78-186-88-125-82+0-185-89-173+34 xof_shake256 2 17 16450 +54+38-183+26-148-83-26+0-174+32+52-40+7-20+143 xof_shake256 2 26 16337 +357+92+13+110-11-3+22-52-38+186+108-91+0-103-125 xof_shake256 2 40 16773 +99+0+63+45-20-16-11+50-112-1+8-68+31+59-64 xof_shake256 2 61 16669 +124+114+73-34-80-9-79+30-3-81+6+0-30+19+8 xof_shake256 2 92 16666 +134+123+131-37+75+94-114-42-1-52-74+80+0-40+64 xof_shake256 2 139 32308 +302+0+86-465-209+11+25-196-91-289-152+36+7-65+20 xof_shake256 2 209 32096 +207+140-112-44-52-202+0-32+144-229-41+107+67+86+132 xof_shake256 2 314 48038 -16+375+345+157+191-122-61-7-30+146+68-166+1-133+0 xof_shake256 2 472 64868 +235-31+40-15-77-47+236-23+103+0+149-47+28+258-6 xof_shake256 2 709 97090 -33-283+115-250+68-51+147+91-239-104+16+72-89+0+18 xof_shake256 2 1064 128824 +523+300+569+34-326+0-163-605-496+61+164-144-228+321-128 xof_shake256 2 1597 189810 +424-109-282+412+250-158+0-323+710+118-132+35+186-584-350 xof_shake256 2 2396 288874 +73-85-136-318-44-656+517+0-208-479+339+100+423+89+586 xof_shake256 2 3595 432859 +679-614-71-940+272+452-595+492-393-238+477+0+105+436-568 xof_shake256 2 5393 641251 +563-1209+266+31+92+234-1254+353-496-602-957+653+0-908-672 xof_shake256 2 8090 962518 -2397+271+333-1420-47+876+1179+924-800-385+0-520+79-1068+141 xof_shake256 2 12136 1443189 +0-2123-3930-2905-2181-1419-1086-2530+43+2403+2695+44+1749+2671+2287 xof_shake256 2 18205 2146925 +4004+3801+3112+3710+0+1073+1073+1250-29316-58185-58177-57587-57615-57798-55779 xof_shake256 2 27308 3207233 -27800-72012-70137-52586+7452+5569+7504+6700+0-3281-2321-3013+3954+12739+13974 xof_shake256 2 40963 4749774 +87168+0-30963-25835-21520-26623+42582+79810+79659+88745+87784+90130-11107-27547-28819 xof_shake256 2 61445 7079878 +153443+23231-15594+112611+153980+160493+154163+0-19330+124185-17744-19735-21162-17784-16120 xof_shake256 2 -1 16552 +256+114+114-84-4-40+8+14+50-35-104+89-18-120+0 xof_shake256 2 -2 16548 +95+0+15-62+47-57-16+89+13-126-76-21+33-33+60 xof_shake256 2 -4 16584 +55-91+21-87-52+0+23-45+32-5+77-44+30+1-121 xof_shake256 2 -7 16550 +61-85-79-17-76+91-58+66-32-122+54+30+15+52+0 xof_shake256 2 -11 16554 +156-27-7+83-8+0-4+2+13-31+176-91+7+90-26 xof_shake256 2 -17 16574 +221+124+19-90+14-44-104-121-75+32-36-15+0+39+18 xof_shake256 2 -26 16590 +146+84-64-128-60-127+17-30+0+21+81-78+86-95+153 xof_shake256 2 -40 16730 +91-64+3+37+42+0-96-104+36-51+7+34-60-68-78 xof_shake256 2 -61 16688 +36+143+90+98-20+0-114-28+0-16+112-12-132+11+115 xof_shake256 2 -92 16742 +114+61-78-11+20+0-17+28-44+35-49-86-60+64+41 xof_shake256 2 -139 32859 +229+57+153-149+101-96+78+218-151-227-31-23-4+0+10 xof_shake256 2 -209 32888 +260+28-120-62+110+44-163-57+30+90-73+0-24+145-142 xof_shake256 2 -314 49105 +175+57-17-147+75-23+199+0+30-143-5+36-10+24-215 xof_shake256 2 -472 65254 +174+79+134+183+163-305+116+223+0-661-1076-985-894-930-1124 xof_shake256 2 -709 97776 +91+132-328-288+0+118-97-86-44+121+702-173+53-56+237 xof_shake256 2 -1064 130127 +215+134-18+0+37-314+323+46+116-137-354-166+69-265-665 xof_shake256 2 -1597 194753 -82-104+56-73-257+148-241-449+0-57+307+102+306+229+147 xof_shake256 2 -2396 292287 +497+181-181-314+148+85+542+94+0+222-1033-4880-5021-4505-5667 xof_shake256 2 -3595 426652 -138-379-194-904+29+41+12+512-390+233-391+248+946+0-11 xof_shake256 2 -5393 647650 +1128-947+0+430+412+275-471+218+776-542-747-249-470-190+132 xof_shake256 2 -8090 971070 +1483-1514+512+73-246-1233-440+0-466-913+81+1175+747+684-12222 xof_shake256 2 -12136 1455747 +330+0-409-585+1259+1959-241-154+555+342+1064+316-1026-1-327 xof_shake256 2 -18205 2167769 +1314+1500+2019+2404+970+1442+0+2232-22719-49682-52019-51933-52695-50883-14107 xof_shake256 2 -27308 3251752 +899+0+1024+3671-1315+1921-872+3604+1269-995+523-22516-73563-74171-74010 xof_shake256 2 -40963 4820815 +76024+51737-7869-11532-8791-5575+0-5390+21362+66400-50229+6720+64854+63935-4173 xof_shake256 2 -61445 7222336 +29688-9768+23195+104727+103838-60003+16811+0-12537-14258-31934-58601+36623+98107-59775 xof_shake256 3 implementation tweet compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 3 0 8819 +4000+1120+637+226+43+27+12-45-54-41+0-33-52-69-126 xof_shake256 3 1 8759 +198-100+55+113+0-36+0+32-200+141-1+14-200+115-36 xof_shake256 3 2 8749 +54-87+16+71-24+7-192+156+19-191-6+85-24+0+0 xof_shake256 3 4 8798 -89+52-188+27-54+0-26+29-27+22+88-227-27+23+49 xof_shake256 3 7 8791 -84+78+0+67-21+26+40-235+26-30+76-15-16-11+20 xof_shake256 3 11 8748 +19+135+79-56-140+34+16+64-194+0-190-82+32-205-189 xof_shake256 3 17 8776 -17+212+40+0-228-87-202-221+17+62+44+44-3-215+44 xof_shake256 3 26 8591 +198+77-29+69+206-42-35+85+7-8+0+62-24-10-24 xof_shake256 3 40 8735 +138+185+141+46-160+20-131+0-213-206+0-207-199-207+33 xof_shake256 3 61 8812 -75+73-37+50+22-8+22+0-3+29-7+29+15-257-78 xof_shake256 3 92 8747 +201+149+69+0+96-34+22-4+110-2-2-2+93-2-2 xof_shake256 3 139 17088 +316+50+71-11-1-82+12-108+22-94+0-57+8-76+87 xof_shake256 3 209 17069 +391+1+18-220-276-226-40+0-51+27-60+94+21+21-293 xof_shake256 3 314 25613 +328+277+214-157-87-138+64+29-26-94+217+0-6+2-107 xof_shake256 3 472 34068 +173+288+77+0-70-61-33-54+49+218-82-21-60+125+95 xof_shake256 3 709 51062 +83+254+111-166+8+35-202-12+2-78+0-86-154+76-22 xof_shake256 3 1064 67976 +238+107+131+38+0+60+76-110-147+6-79-84-57-132-180 xof_shake256 3 1597 101975 +167+104+41+34-254-96+187-23-99+138+103-101+0-124-96 xof_shake256 3 2396 152841 +307+340-388-104-251-36+88-149+166-27+184+0+101-254+276 xof_shake256 3 3595 229010 +326-13+117+127-204-126-199+178+7-243+167+137+0-250-9 xof_shake256 3 5393 339141 +0-279+124+188+396+55+48-210-422-253+60-4+181-194-23 xof_shake256 3 8090 508577 -208+173-203-106-2+251+0-273+90+151-159-162+53+22+7 xof_shake256 3 12136 762433 +0-117+404+79+191+4-40+33-17-118-94+82+1-550-438 xof_shake256 3 18205 1134995 +446+0+115-586-519-12+245+58+389+53-292+160-359-470-383 xof_shake256 3 27308 1702398 +106+22-588-141+486+48-463-121-18+52+0+266-8+77-492 xof_shake256 3 40963 2557228 +515+127-1030-1143-455+277+211+208-617-214+791-303+0+194-557 xof_shake256 3 61445 3827420 +798-1014-36+787-306+255-399+814-396+158+464+0+715-340-33 xof_shake256 3 -1 8519 +249+318-15+75+0-25+0-34+328-39-14-43+161-25+0 xof_shake256 3 -2 8747 -155+48+16+14-219-248-92+60+42+25-37+0+80-44-92 xof_shake256 3 -4 8698 -124-130-10+88-9-29+19+40-7+0+19+75+19-29+19 xof_shake256 3 -7 8716 -94-176+4+35+27+82+31-10+7+0+38-239-8-19-54 xof_shake256 3 -11 8743 -96+46+25+34+0-56+24+43+0+24-30-37+1-20-22 xof_shake256 3 -17 8748 -21+26+16+60-52+0+31-12-16+6+57-40+26-31-105 xof_shake256 3 -26 8753 -77-178-167+93-3+24+0+93-1+49-29+97+11+49-1 xof_shake256 3 -40 8790 -104-136-188+158+23+26-10+97-14-8+4+113-6+60+0 xof_shake256 3 -61 8844 -88-112-215-6+55+0+5+49+5-16+18+93+0+25-16 xof_shake256 3 -92 8927 -30-221+18+58+2+0+82+8-29+11-228+0-51+20+0 xof_shake256 3 -139 17632 -259+108+4-59+10+0+8-91-251+80-7+64-215+9-7 xof_shake256 3 -209 17827 -173+90-77-10-31-4-42+40+53-37+92+1+0+6+44 xof_shake256 3 -314 26644 -172+84+144+18+69-54-18+0+65-174-219+60+43-64-157 xof_shake256 3 -472 35618 -156-172+83-16-18-8+25+95+33+0+48+33-68+85-31 xof_shake256 3 -709 53361 -178+82+5-257-45-19-178+13+116+59-55+122+38-129+0 xof_shake256 3 -1064 71234 +59+0+337-29+163-29-27+205-74+113-296+146-22+125-217 xof_shake256 3 -1597 107007 +0+36+22+49-126+1+72-73+114+153-220-154-62-119-82 xof_shake256 3 -2396 160500 -124+189-223-86+42-74+0+696+0+221-74+238+117+99-48 xof_shake256 3 -3595 240436 +12-31+192-60+78-57-2+18-99+327-8-126+0+196+126 xof_shake256 3 -5393 356334 -188+0+496+300-32-57-193+108+278+298-32-57-193+108+278 xof_shake256 3 -8090 534444 -60+13-157+4-223+292+215-137+23-159-34+0+87-143+87 xof_shake256 3 -12136 801299 -121+224+25-339-357-358-345+0+191-288+484-90+641+220+473 xof_shake256 3 -18205 1193432 -374+659-180+672-372+578-1017+1080+459-396+267-669+0-399+301 xof_shake256 3 -27308 1790554 -1588-1493+0-132-15+11+505+92-511-20+700+91+254+335-450 xof_shake256 3 -40963 2688920 +1565-459+0-865-175-363+1555+1568+2116+1528+1219+1983-468-444-110 xof_shake256 3 -61445 4024708 +1859+2239+2820-941-6589-7862-6757+1205-474+1230-1261+2090+0+1757-687 xof_shake256 4 implementation unrollround compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 4 0 2024 +7482+179+91+9+6+0+0-2-2-2-2-2+1+3-2 xof_shake256 4 1 2005 +197+50+32-3+0-6+0-8+0-6+0-8+2-8+0 xof_shake256 4 2 1997 +195+45+3+2+3+0-3-1-1-1-1-1+6+0+6 xof_shake256 4 4 1994 +193+44+8+12+7+11+0+0+0+0+0+0+0+0+13 xof_shake256 4 7 2001 +138+32+3+4+0-1+1+5+5-6-7-7-3-7-7 xof_shake256 4 11 1996 +183+39+18+3+4+1+0-4+0+0-3+2-3-4+0 xof_shake256 4 17 1997 +224+73+8+4-2+0-3+0+1-1-1-1-1-1+1 xof_shake256 4 26 2002 +156+33+2-2+2-2+1+0+0+0-1-6-6-2-6 xof_shake256 4 40 2000 +180+24+15-3-2+4+4+3+0+0+0+0+0+0+0 xof_shake256 4 61 2001 +188+29+3+2-3+3+3+3+0-5-5-1-1-1-1 xof_shake256 4 92 1998 +245+48+12+9+4-1-1+0-1-2-1+0+1-2-1 xof_shake256 4 139 3669 +532+159+29+33-11-8-11-8+3-16+0+14-4-9+3 xof_shake256 4 209 3664 +255+26-5-6+0+7-3+4-4+4+1-3-8+1-3 xof_shake256 4 314 5389 +279+10+4+3-5-6+1+2-2+0-6-3+2-2-4 xof_shake256 4 472 7090 +345+50-1+0+3-4-2-2-3+6+0+18+5-4-1 xof_shake256 4 709 10368 +317+2-8-26+28-34+0+13-20-10-20+46-8+26+15 xof_shake256 4 1064 13743 +313+47+30+0+19+19+8+20-24-41-22-42-49-45-69 xof_shake256 4 1597 20670 +353+33-2+7+13+3-2-2+11+0+0+14+0-6-8 xof_shake256 4 2396 30561 +382+21+0+107+80+27-42-6+95-29-60-29-12+77-14 xof_shake256 4 3595 45734 +381+24-67+23-18+9+0-85+26-6-17-41-89+28+16 xof_shake256 4 5393 67532 +263+35-10+44-2-24-46-6-24+20+0-22+52+52+18 xof_shake256 4 8090 101000 +277-81-6-28+24+28+18+0+84+896-27-41+22-28-20 xof_shake256 4 12136 150066 +1293+83+6-60-226+53-187-19-293+0+10-103+3-267+51 xof_shake256 4 18205 226877 +170+17-146+167+4-172+194-180+68+0-193+194-218-104-116 xof_shake256 4 27308 334595 +1599+48-42+41-85+76-398+25-305+60+10-48-54-268+0 xof_shake256 4 40963 502590 -1099-626-74+42+467-27+540+0+540+0+540+0+540+0+540 xof_shake256 4 61445 763891 +592+503+363+9+0+170+181+93-6814-11193-11486-11793-12428-11349-11417 xof_shake256 4 -1 1828 +317+128+2+0-4+4+0-2+0-1+0-8-6-9+0 xof_shake256 4 -2 1829 +246+118+10+2+0+0+0+1+1+2-5-5-5-5-6 xof_shake256 4 -4 1839 +240+121+21+13+7-1-5+0+0+0+0+0+0-5-1 xof_shake256 4 -7 1856 +240+129+20+6+0+5-3-4+0-4+0-4+0-4+0 xof_shake256 4 -11 1880 +204+136+31+2+13-2+0-4+0+0+0-4-4-4+0 xof_shake256 4 -17 1914 +196+83+12+5+10+0-2+0+0+0+0+0+0-1+1 xof_shake256 4 -26 2006 +145+48+13+18+11+5+0+0-1-39-40-36-40-36-40 xof_shake256 4 -40 2036 +224+98+40+36+8+2+0+0+0+0+2+0+0+0+0 xof_shake256 4 -61 2145 +201+60+55+24+4+1-1-2-2+0-5-1-2+0-2 xof_shake256 4 -92 2326 +163+31+26+50+9+4-1-3-4+0-1-3+0-1-3 xof_shake256 4 -139 3612 +342+60+20+10+0+1-1+0-4+0-4+0+0+0-4 xof_shake256 4 -209 4011 +255+17+4-21-32-35-24+0+0-4+0-4+0-4+0 xof_shake256 4 -314 5653 +230+57-12+2-19+1-5+1-12+0-12+0-12+0-12 xof_shake256 4 -472 7558 +230+84+4-5+8-8+0+2-2-2-2+0+0-2-2 xof_shake256 4 -709 10935 +276+106+26-1+15+6-23+21-22-4+0+0-21+22-21 xof_shake256 4 -1064 14952 +220+40+94+20+8-11+33-44-2-18+0-44-2-18+0 xof_shake256 4 -1597 22003 +209+37+58-16+0-19+1-22+1-22+1-22+0-22+0 xof_shake256 4 -2396 32571 +237+55+48+41-4-18+1-18+0-17+1-18+0-17+1 xof_shake256 4 -3595 48464 +269+70+16+28+72-4+0-16+0-53+4-23+4-22-34 xof_shake256 4 -5393 71755 +185+44+59-14+0-16+0-16+0-16+0-16+0-16+0 xof_shake256 4 -8090 107279 +102+0+12+0+30+4-5-8+2+2+26-61-48-46-38 xof_shake256 4 -12136 160326 +199+73+83+8+0-24-6-22+2-32-12-24+825+34-5 xof_shake256 4 -18205 238935 +174+50+54-16+0-32+0-32+0-32+0-32+0-32+0 xof_shake256 4 -27308 357867 +47+56+47-32+11+6-12-16-1-32+16-32+13-4+0 xof_shake256 4 -40963 536846 -77+76+39+0+42+662+45+30+13-12-26-6-40-12-38 xof_shake256 4 -61445 803768 -210+62+43-17-8-9+14-38+0+730+39+10-22+16-42 xof_shake256 5 implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 5 0 1754 +585+160+54-2+14+12+14-1+4-9+0-1-4-4-4 xof_shake256 5 1 1758 +319+123+46+0-2-4+12-4-17-11+5+4-6-4+6 xof_shake256 5 2 1764 +244+57+7+6-3-5-1-14-3-5+0+0+0+0+0 xof_shake256 5 4 1764 +253+22-3-5-13-3-19+12+0+0+0+0+0+0+0 xof_shake256 5 7 1757 +179-1+11-15+3+0+23+6+2+5-3-3-3-3-3 xof_shake256 5 11 1755 +250+48+0+0-2+8-8-6+7-8-8+2+1-20-8 xof_shake256 5 17 1759 +280+54+17-4-5-25+9+1-25+0+10-25+0+10-25 xof_shake256 5 26 1755 +226+30+25+1+0-14+7+24-2+1-3-5-2-8-3 xof_shake256 5 40 1754 +279+66+16+1-10-5+4-10+0-2-5+2+0+7-5 xof_shake256 5 61 1750 +290+15-1+8-1+10+0-1+5+0-1+5+0-1+5 xof_shake256 5 92 1752 +269+42-2+2-2+7+8-3+0-1+1+0+0-1+1 xof_shake256 5 139 3301 +321+71+35+30+15-23+13-18+0-13-21-1-18+4-21 xof_shake256 5 209 3292 +379-5+3-8+16+7-6-13-4+4+0-4+4+0-4 xof_shake256 5 314 4832 +359+66+23+44+23-13+0+9-14+0+0+0+0+0+0 xof_shake256 5 472 6382 +395+34+14+34+24-8-19-23+0-19-21-18+6-18+6 xof_shake256 5 709 9495 +306+28+12+0+32-17-19+23-5-25+5-22+12-19-22 xof_shake256 5 1064 12520 +371+94+86+17+30+0+0+0+0+0+0+0+0+0+0 xof_shake256 5 1597 18788 +247+16-12-12+0+2-45-7+16+0+0-14+0-26+16 xof_shake256 5 2396 28066 +325+49+12-13-20+0+0+0+2+0+28+0+0+0+0 xof_shake256 5 3595 41942 +281+223+82+1-37+101-32-43+0+101-32-43+0+121-33 xof_shake256 5 5393 62001 +197+121+54-33-28+89-58+22+0-26-7+0-102-5+12 xof_shake256 5 8090 92866 +244+99+10+49-38+30+53-16-18-26+12-27-36-35+0 xof_shake256 5 12136 139074 +425+101+34-14+0+0+0+0-3+72-29-16-2-13-13 xof_shake256 5 18205 206829 +592-7+23-43+0-6+0+35+94+49-28-49-54+43+47 xof_shake256 5 27308 310074 +435+140-33-105-19+0-40-4+166+2-31+34-35+90+1 xof_shake256 5 40963 467086 +288+249+0+39+27-204-65-9-156-172+1106+123+62-157-209 xof_shake256 5 61445 698606 +403+333+380-17+4+5+250-120-125+0+0+0+0+0+18 xof_shake256 5 -1 1618 +259+62+32+16-7+9-11-2+9+0+14-4-11-2-9 xof_shake256 5 -2 1622 +225+31+5-5+0+19+0-13+0-11+1-8-11+1-8 xof_shake256 5 -4 1631 +247+27+62-8-2+6+2+0-13+2+0-13+2+0-13 xof_shake256 5 -7 1640 +205-3-1-2+0-2+7+8+21+0-3+3+4+0-3 xof_shake256 5 -11 1660 +272+56+31+6-3-5+6+0+0+0+0+0+0+0+0 xof_shake256 5 -17 1690 +249+12-7-5+7-6+11+0-4+1-3+1-3+1-3 xof_shake256 5 -26 1742 +185+69-19-18-14-31+5-25+0+0+0+0+0+0+0 xof_shake256 5 -40 1815 +262+48+0+10-10+11+0-5-8+0-8+0-8+0-8 xof_shake256 5 -61 1918 +210+13+0-13+2-6+9+13+10+6-7+0-4+0-4 xof_shake256 5 -92 2058 +202-16+17+34+7+10-4+1+18+0+0+0+0+0+0 xof_shake256 5 -139 3128 +404+100+39+12+8-4-3+0+2+11-4-4-4-3+0 xof_shake256 5 -209 3487 +281+24+42+44-3-5+11-11+0-1+12-5-5+7-11 xof_shake256 5 -314 4857 +335+73+0+15+14-9-4+3-13+8-3-4-12-4+39 xof_shake256 5 -472 6489 +337+66+3+25+2-8+0-10-6-5+19+0-6-1+37 xof_shake256 5 -709 9350 +311+31-11+0+2+18-7-4-2+27+2-4-12-19+28 xof_shake256 5 -1064 12822 +294+45+46+56+18+34-4+0-17-8-23+14-24-9-36 xof_shake256 5 -1597 18848 +216+45+0+18-18-31+0+15-18-31+0+15-18-31+0 xof_shake256 5 -2396 27883 +285+37+0-51+30+9-26+15-33-46-30-36-38+1+19 xof_shake256 5 -3595 41430 +373+131+10-24-4+9+44-49+63-42-42-12+0-41+30 xof_shake256 5 -5393 61338 +304+54-16+0+3+12-22-17+29-76-14+31+3-102-70 xof_shake256 5 -8090 91535 +363+257-39+24-54+0-92+0-92+0-92+0-92+0-92 xof_shake256 5 -12136 136858 +428+111-85-38+0+104-35+37-12-92+49-50+47-5+3 xof_shake256 5 -18205 204019 +395+128+27+97-137+9-27-125-85-27+93-85+0-38+20 xof_shake256 5 -27308 305622 -2822-33-63+60+60+92+72+0+924-64+42-59-71-53+20 xof_shake256 5 -40963 458360 -4266+207+202-26-16+226+158+50-13+172-22-66+178-22+0 xof_shake256 5 -61445 686304 -6629+153+188+0+1245+74-87+148-136-360+178-344+130-12-212 xof_shake256 6 implementation unrollround compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. xof_shake256 6 0 2355 +3517+208+24+16-14+1-17+0-1-16-1+1-17+0-1 xof_shake256 6 1 2360 +248+8-14+3-9+8-20-4+0-19-4+0-19+0+0 xof_shake256 6 2 2358 +225+66-19+4-7+1-12-1-2-15+0+4-19+4+4 xof_shake256 6 4 2360 +214+81-29-2+1-23+8+0-12-3+8-20+8+0-12 xof_shake256 6 7 2366 +212+82+0+7-22-9+4-28+0-8-16-4+4-28+0 xof_shake256 6 11 2359 +220+41-26-2+0-18-6+0-20+0+0-20+0+0-20 xof_shake256 6 17 2357 +231+86-24+5+1-23-4+3-17+0+3-17-1+3-17 xof_shake256 6 26 2356 +260+49+5+5-24-3-1-22-1+3-16+0+3-16+3 xof_shake256 6 40 2359 +219+0-22+11-15+0-20+2+2-19+2+0-18+8+1 xof_shake256 6 61 2359 +248+82+7+2-19-3-1-20+10+0-12-2+8-20+10 xof_shake256 6 92 2362 +204+77+5-1+46+0-2-22-1+1-19+3+1-19-1 xof_shake256 6 139 4363 +541+70+17+24-2-21+0+0-20-3+0-23+0+0-24 xof_shake256 6 209 4408 +338+68+44-6+8-31-10-10-30+0+20-19+1+1-2 xof_shake256 6 314 6486 +416+192+108+19-2+0-1+3-6+4-1-17-1+3-21 xof_shake256 6 472 8492 +534+183+77+28+12-2+22+0+21-83-96-110-96-90-85 xof_shake256 6 709 12635 +411-14+25-1-5+0+5-30+7+15-22-3+3-30+4 xof_shake256 6 1064 16721 +409+17-4-2+17-22+0+2-5+0-1-22+0+5-24 xof_shake256 6 1597 24982 +347+17-10-2+16-24+0+0-24+0+0-24+0+0-24 xof_shake256 6 2396 36592 +1169+676+282+20+60-43-9-22+23+0-15-53+37-2-43 xof_shake256 6 3595 55600 +415-3+43-21+63-42-19-30+35+0+23-46+6-14+37 xof_shake256 6 5393 82196 +464+66+7+17+1-9+1-1-8+0+0-7-2+0-9 xof_shake256 6 8090 121091 +2353+2876+1071+20-6-6-10-3+29-11-11-9+8+19+0 xof_shake256 6 12136 184310 +581-99+29-104+40-128+11-132+0-114+30-122+30-119+11 xof_shake256 6 18205 273480 +647+34+22+12-1-4+3+0-9+1-2-10-1+0-12 xof_shake256 6 27308 410784 +1020+161-14-6+14-16-10-2-8-2+1201+88+0+12+32 xof_shake256 6 40963 617490 +641-29+70-84+14-83+44-35+39-96+0-84+44-74+66 xof_shake256 6 61445 923774 -99+142+98+38+23+24-10-30-10-42+52-66-12+4+0 xof_shake256 6 -1 2154 +318+72+5+9+0-1-1+4+0+0+0+0+0+0+0 xof_shake256 6 -2 2173 +292+140+104+15+0-12-3+674+77+0-7-7-13-9-14 xof_shake256 6 -4 2184 +280+165+84-3+5-5+0-5+2-5+0-5+0-5+0 xof_shake256 6 -7 2216 +231+151+59+37-7+2-12+0+0-14-2+0-19+0+0 xof_shake256 6 -11 2243 +266+75+0-18-5-2-21+0+1-18-2+1-18+0+1 xof_shake256 6 -17 2275 +250+123+33+7-2+0-20+2+0-18-1+0-18-1+0 xof_shake256 6 -26 2326 +284+138+83+82+0-25+2-2-16-4+3-23+2-2-16 xof_shake256 6 -40 2430 +293+138+23+4-19+0-9-3+5-20+3-3-12-3+5 xof_shake256 6 -61 2555 +223+76+3-1-11+9+0-8+0+10-11+9+0-8+0 xof_shake256 6 -92 2725 +231+80-8+2-10-7+8-22+8+0-11-7+8-22+8 xof_shake256 6 -139 4354 +416+218+72+35+0-9-2-6+0+58-9+0-9+0-6 xof_shake256 6 -209 4793 +325+179+54+29+0-5-15-8+0-26+0-5-15-8+0 xof_shake256 6 -314 6806 +288+108+114+50+21+3+0-20+0-1-20+3+0-20+0 xof_shake256 6 -472 9125 +398+80-9-10-25-2+0-16+0+62-13+7+0-14+0 xof_shake256 6 -709 13265 +306+160+41+26-16-7+32-39-14+2-30+0-11-41+11 xof_shake256 6 -1064 18106 +326+65-11-9-15+6+21+33+11+0-19-17-1+32+0 xof_shake256 6 -1597 26780 +254+51+93+56-30+4+0-19-4+0-29-5+1-18-3 xof_shake256 6 -2396 39746 +247+53+91+61-27+7-1-20+0+3-23+9-1-16-4 xof_shake256 6 -3595 59248 +217+154-1+102-37+59-29+0+16-35-10-40+15-49+15 xof_shake256 6 -5393 87724 +193+150+58+8-3+11+2-3+3+0+0-2+0-6-2 xof_shake256 6 -8090 131216 +436+60+81-37+5+2-28+0+4-11-15-20-27+10-1 xof_shake256 6 -12136 196301 +279+182+54+28+44+28+6-10-29-5-13-27-29-20+0 xof_shake256 6 -18205 292544 +425+70+93-25+1+0-14-3-3-1-17+790+57+44-16 xof_shake256 6 -27308 438326 +298+121+19-8+17-18-2+16+22-16-4-12-12+10+0 xof_shake256 6 -40963 657751 +228+129+3+0-1+7-39+825+71+13-64-30-88-54-97 xof_shake256 6 -61445 984845 +536+130+55-27-10-42+0+785+87-19-48+6+0-52-15 xof_shake256 7 implementation unrollround compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin xof_shake256 7 0 1947 +3355+125+42+31+6-13+0-3+8+0-13-13-9-9-9 xof_shake256 7 1 2026 +221+80+88+7+6+6-11+4-6+0-6+0-6+0-6 xof_shake256 7 2 2049 +180+44+46-1-4+1-6+0+1-6+0+1-6+0+1 xof_shake256 7 4 2033 +162+66+13+57+21-4+0-4+0-4+0-4+0-4+0 xof_shake256 7 7 2033 +117+47+55+14+17+11-4+0-4+0-4+0-4+0-4 xof_shake256 7 11 2050 +152+23+1+38+3+0+0+0+0-25-36-36-36-36-36 xof_shake256 7 17 2045 +170+43+5+0+1+3-10+4+3-31-19-19-19-19-19 xof_shake256 7 26 2018 +197+38+15+17+7+11-8+0-6+0-6+0-6+0-6 xof_shake256 7 40 2028 +168+63+57+15+11-10-5+0+0+0+0+0+0+0+0 xof_shake256 7 61 2030 +151+34+51+41+4+10+0+3-9+0+0+0+0+0+0 xof_shake256 7 92 2030 +187+67+51+19+2+0-1-2+0-2+0-2+0-2+0 xof_shake256 7 139 3701 +328+105-9+10-6+0-6+0-6+0-6+0-6+0-6 xof_shake256 7 209 3735 +213+83+5-13-16+0-16+0-16+0-16+0-16+0-16 xof_shake256 7 314 5401 +305+113+2-9+4-6+0-10+0-10+0-10+0-10+0 xof_shake256 7 472 7068 +316+33+16+25+11-3-2+0-2+0-2+0-2+0-2 xof_shake256 7 709 10423 +392+21+28+25-12-10+15+0-17-12-3-22+3-8+4 xof_shake256 7 1064 13806 +330+23+7+1-11-3+18-45-34+0-3-22+17-33+15 xof_shake256 7 1597 20522 +268+58+28+26+15+0-2-4+0+0-3+15+0-2-4 xof_shake256 7 2396 30583 +205+16+18+10-32+0-32+0-32+0-33-33-32+0-31 xof_shake256 7 3595 45645 +346+137+51+0+11+76-16-38+57-97-125+26-112-108-152 xof_shake256 7 5393 67442 +448+191-2+0+4+0-65-38-37-17+22+13-19+22+13 xof_shake256 7 8090 100991 +416+48-26-27-27-32+834+168+51+15-5+0+40-5-5 xof_shake256 7 12136 151183 +430+100+25+15+0-30+0-32+12-32+0-32+0-32+0 xof_shake256 7 18205 225052 +286+56-8+8+0+0-2+0-19-85+1-83+2+0+0 xof_shake256 7 27308 337358 +682+0+140-38-92+0+128-34-32+6+128-32-85+21+126 xof_shake256 7 40963 508742 +399+845+0-94-65-24+110+45-65-24+110+45-65-24+110 xof_shake256 7 61445 761272 +436+54-198-144-74-76-68+983-43+2+0+0+4+4+0 xof_shake256 7 -1 1765 +366+108+23-6+2-8-19-20+0-20+0-20+0-20+0 xof_shake256 7 -2 1760 +225+115+38+7+6+11-9+0+0+0+0+0+0+0+0 xof_shake256 7 -4 1762 +198+84+70+14+20+12+3+0+0+0+0+0+0+0+0 xof_shake256 7 -7 1806 +203+76+16+9+13+5+12-1+0-1-1-1-1-1-1 xof_shake256 7 -11 1848 +164+33+11-3+12-2+0+0-9-8+11+0-9-8+11 xof_shake256 7 -17 1841 +218+77+83+9+78-1-1-10-11+0-12-12+3-7+5 xof_shake256 7 -26 1891 +208+138+93+91+1-4-16+0-16+0-16+0-16+0-16 xof_shake256 7 -40 1977 +254+178+3+8-2+8+0+2-1+2-7-7-7-7-7 xof_shake256 7 -61 2085 +260+11+6+1+3+3+1+0-16-14-10-13-5-14-10 xof_shake256 7 -92 2237 +183+130+166+170+4+9+3-13-6-6+0-6+0-6+0 xof_shake256 7 -139 3763 +415+73+18+15+13+9-7-5-4-3+0+1-4-6-5 xof_shake256 7 -209 4141 +382+69+35+9+8+10-5-8+0-1-3-5-8+0-1 xof_shake256 7 -314 6060 +230+73+36+24+20+0-2+0-7+1+0+2-2+0-7 xof_shake256 7 -472 8215 +215+8-4+13+16+0-10+0-11-8-8-8+1-7+3 xof_shake256 7 -709 11932 +399+114+59+5+0-27-9+20-20-49+0+13-33-14-14 xof_shake256 7 -1064 16384 +348+113+57-31+0+21+20+11-6-15-23-17-9+6-22 xof_shake256 7 -1597 24337 +309+181+0+4+11-5+7+6+11-20-3-26-11-20-3 xof_shake256 7 -2396 36501 +236-33+15+0-5-7-5-18+24+8+2-26-4+0+0 xof_shake256 7 -3595 54440 +223+52-6+13-5+108-13-49+146-31-74+128+0-47+135 xof_shake256 7 -5393 80861 -14-117-277+5-67-106+24+25+41-2+0+82+36-2+0 xof_shake256 7 -8090 120698 +121-64-166+56+0-146+5+21-81+31-2-76+23+20-44 xof_shake256 7 -12136 180313 +249+141+0+141-8+965+42+10-7+69-103-22-104-22-104 xof_shake256 7 -18205 268658 +409+203+250+50+0+0+116-18-18-20+60-10-10-6+110 xof_shake256 7 -27308 402776 +240+17+26+42+58+0+78-90+142-184-158-134-172-184-156 xof_shake256 7 -40963 604524 +1190+35+312+8+0-1+214-96-108-68+206-94-50-82+274 xof_shake256 7 -61445 905106 +46-245-294+410+690-81+353-16-82+0+214-36-226+7+277 kem_6960119 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair selected 1047319 314300044 +532265-77760591-77958303-43943-77829055-77795848-77741050+155707124-77770368+311816851+0+234445012+256717+1070065+78345458 kem_6960119_enc selected 194 150145 +8454-607-479+2923+7661-2232+4703-1442-109+6417+0+5299-1812-3115+1266 kem_6960119_dec selected 194 284727 +30548+3123+844+682-22+39-365+295-428-214-489-2274-553+1066+0 kem_6960119 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119_keypair 0 1047319 456269588 +347578699+0+159414-85638027+601320966+343527567-85812203+237017-171614857+258009611-85760056-171703447-171552420+85915934-171658685 kem_6960119_enc 0 194 184743 +3854-1705-3302+12377-109-3718+459+0+4501-3288+710+4619-3848-4129+5753 kem_6960119_dec 0 194 313745 +26273+2070+609+0+111-22-85-56-80-331-77+119+311-50+761 kem_6960119 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair 1 1047319 392124263 -77654298-155707287+234129188-155712939-155634152+237559+233882933+78199693+91157-77888851+156141565-61290-155729560+0+95589 kem_6960119_enc 1 194 151019 +2112+8374+5320-4604-4601+0+5226+7530-81-80+5530+162-1886-4371-1873 kem_6960119_dec 1 194 282600 +19284+1379+463+92+228+31+196-100-76-29+0-143-213-50-45 kem_6960119 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119_keypair 2 1047319 1709779648 -406786+810493926+811537854+404622866-406279906+810139922-405930822-1090392-457549-403865630+0+404482257+404369786+404810135-938856 kem_6960119_enc 2 194 411856 +10121+51600+6496-1308-12739+37367-12339+15798-11452+17413-14031-2218+16983-2438+0 kem_6960119_dec 2 194 2472355 +42213+7705+5713+2108+891+1251-575-1607-913+108-397+0-1282-19-2359 kem_6960119 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair 3 1047319 1243160248 +952587775-191108102-191264487-381779094+190585311-572659246+418729896-191047271-572544367+190521587+762711275+0-381928986+37555814+571823230 kem_6960119_enc 3 194 149572 +46011+10737+0+17743+18022-9135-9350+104+8743-9418-9423-318+42807-431-9355 kem_6960119_dec 3 194 1984201 +49422+7770+2677+2357+1041-187-857-367+24-540+840+0-820-430-679 kem_6960119 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119_keypair 4 1047319 1743683990 +427389631-427258569-8235+1168868-425946791+427687263+278802+87700-427301920+0+3845864338+854625121-427208185-427301323-427270523 kem_6960119_enc 4 194 416053 -4763+0+17182+22882+32240-5796+22459-5474-4989-14327-5529+13556-14764+40546+67890 kem_6960119_dec 4 194 2551973 +36519+10895+7303+4464+1393-223+377+77-1516-1236-2901+0-2466-1584-180 kem_6960119 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119_keypair 5 1047319 1070971093 +731066002-243864584-243982039-215539-243791619+731123496-457763+1218275627+243614117+0+1218383255+243367797-243336357-243865984+243621432 kem_6960119_enc 5 194 233826 +3056+7512+46479-7023-1049+2287-7754-8025+0-7566-7913+671+77484-12005+37253 kem_6960119_dec 5 194 1637910 +32075+4798+2756+763+17+0-120+1895+661-313-1248-609-845-496-920 kem_6960119f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair selected 1047319 236682327 +78591+65845-147532-16043+0-86049-60327+126930+10395-107516-73029-46956+49968+82891+25385 kem_6960119f_enc selected 194 149693 +5674+5529+23867-3017+7181-623+4143+2430-2260-594+2359-329-476+0-2694 kem_6960119f_dec selected 194 282498 +27783+1350+702+86-185+74-119-153-250-186-74+63-403+0+296 kem_6960119f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119f_keypair 0 1047319 287945711 -47451+115969-75964-90040+23945+30759+146636-9049+1901+42847+0-29223-36346-71539+158343 kem_6960119f_enc 0 194 186983 -227-4692+1399+543-5023-5437-5929-5772+9030+0+8132+14486+2615+22-5297 kem_6960119f_dec 0 194 313797 +20161+1684+130+521+348+593-260-180-186+0-250-322+326-140-382 kem_6960119f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair 1 1047319 236640623 -19937+147879-18060+100440-50047-16488+0+124561-94223-31404+88211+98205-16570+61482+23764 kem_6960119f_enc 1 194 149592 +1536+0+5331+4696-2770-355-2337+2038+14036+11512-3044-2501-2619+5140-340 kem_6960119f_dec 1 194 282614 +10237+1015+184+42-39-117+680+1465+0-33-138-329-296-170+30 kem_6960119f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119f_keypair 2 1047319 1382640096 -253821-112987-280821-31926+130277-137535-441866+848957+51020+212278+350360+681590+140081+0-308685 kem_6960119f_enc 2 194 417478 +3472-16101+12860-17597-16700+48829+56613+12310+0-8317-7798+505+10929-18810-17927 kem_6960119f_dec 2 194 2479204 +38725+7244+4140+0+1889-177+2848+1128-2658-1480-4106-873+118-2396-1704 kem_6960119f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair 3 1047319 728952515 -75097-112728-69199-120746+37929045+28950+0-12670+2153+10418+40749-31622-94153+249312+274 kem_6960119f_enc 3 194 147663 +35802+37886-8644-7641+19466-8236-8446+17933+17998+44074+27380+0-335-9296-391 kem_6960119f_dec 3 194 1984186 +44422+7842+3846+1552+618+236+0-330-517+1534-860-500-358-243-743 kem_6960119f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119f_keypair 4 1047319 1405887237 -38033+147309-50761+612308-28988+770124+466732-91638-106814+5506-38495+116695+146592-176977+0 kem_6960119f_enc 4 194 419266 +1910-5609-16866-8064-8344+10403+19191-16313-17735-17220+0+38768+241+27871+8586 kem_6960119f_dec 4 194 2553978 +36041+10199+6792+1947+1296+1035+0-855-603-2277-2435-3+207-402-2622 kem_6960119f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119f_keypair 5 1047319 826717725 -8926+171575+550782-24134-399+5174-4573-76042-28188+0+90403+130896+20375+79863-30367 kem_6960119f_enc 5 194 235073 +35126-8158+6274-13292+28786+420+9436-12847-13170+0-9080+8756-4363+18353-9601 kem_6960119f_dec 5 194 1637912 +30049+5367+2076+544+345-438-738-469-1326+1741+35-1607+0-1868-826 kem_6960119pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair selected 1047319 470162884 +545859825-77669691-233734073+546154526+78584119-77855349+389785900+311626521+467653503+0-233754487-233854707+77922943-77875364-155968372 kem_6960119pc_enc selected 226 165004 +2098+678-2483+4734-464-2985-2933+0+4543+4583-225-3345-765+6685+4317 kem_6960119pc_dec selected 226 294916 +17305+1732+822-24+379-354-90+156-41+275+3-202-278+0-245 kem_6960119pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pc_keypair 0 1047319 542250291 +85802778+171710587-257652265-85829419+343229427+85859165+309658+224880+0-257708726-257680203+26064-85785789-171785645-85775386 kem_6960119pc_enc 0 226 198925 +7432-771-3248+4509-1279-1975+1109+6947+1081-4196-1521+13631+16318+0-3317 kem_6960119pc_dec 0 226 326852 +17700+2148-252+31+1434+466+0-168-612-366-318+132-440-359+59 kem_6960119pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair 1 1047319 470270985 +78013073+78030651+390252872-156255054-155843827-233994218-233823969-233907614+23501+311467750-234006479+155686308+0-233782999+546204977 kem_6960119pc_enc 1 226 164013 +8589-1707+964+0+3099-1946-2553-2374-2426-2624+6748+428+305-2234+6034 kem_6960119pc_dec 1 226 295118 +10808+1079-7+380+1842+932-65+0-208-108-51-86-150+41+100 kem_6960119pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pc_keypair 2 1047319 1709031405 +1728649923-405336564-405705850+405298614+1217400547+0+342943+405188976-405455625-489589-405505445+4054724699-405741495-405231011+405379876 kem_6960119pc_enc 2 226 422332 +22619+19519-6261-9397+819-8877+10702+0-9546-9517-9379+19944+94642+52-365 kem_6960119pc_dec 2 226 2480906 +35220+7645+2512+4950+972+0-1048-1198+136-1014-1298-1330-783-527+412 kem_6960119pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair 3 1047319 861410185 -256027+762813945+0-190722261+1144683642+381555873+190595814+190734195-111130-56412-280510-222028-190934464+190779315+190787720 kem_6960119pc_enc 3 226 163570 +15068+41280-8769+18781+52385+103632+16710-8990-8759+0+8681-234-8921-8914-9101 kem_6960119pc_dec 3 226 1870060 +36083+7773+2744+1547+1441+0-761+183+1049-2200-355-1920-2188-717-2321 kem_6960119pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pc_keypair 4 1047319 1743720180 -427227054+535054-44247+427244216-7144+427241340-427378097-427343688-79483+1709392475-427318498+11940+427398986+0+854603422 kem_6960119pc_enc 4 226 430358 +20765-8239+2302+27321-9191+592-18437-17963+27731+8855-18163+54-8497+0-17633 kem_6960119pc_dec 4 226 2560251 +35874+8382+2443+2392+0+2320-772+63-390-1475-474+763-1092-793-596 kem_6960119pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pc_keypair 5 1047319 1314401668 -243485090+0-487274092-243672583+259416+52512-243474942+487553265-487206328+2679913849-487325299+487326958-487305054+243945657+487492981 kem_6960119pc_enc 5 226 251485 +24989+22843+2012-7506-7591+0-10580-8020+75842-10605+1950-10452+574-7339+10022 kem_6960119pc_dec 5 226 2036431 +28200+5423+2979+2022+3028-1212+452+0-881-163+215-411-1095-705-993 kem_6960119pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair selected 1047319 236687814 +200650-15367+34666+90215+0+127685+28390+16756-66936-79232-69468-74336-17968+74696-9814 kem_6960119pcf_enc selected 226 166779 +7474-1437-2191-1928+0-40+617-4545+393+14903-5235+160+596+8128-2113 kem_6960119pcf_dec selected 226 295207 +13673+1263+165+1113+1952+0+256+95-55-264-470-190-80-154-366 kem_6960119pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pcf_keypair 0 1047319 287967172 +61496+3792-97534+139890-92697+0-38009-94928+73380+17408-55286+17813-33713-113843+179397 kem_6960119pcf_enc 0 226 198472 +3727-3244+0-4260+9889+309+5046+10518-948-1080+2684-20+6528-4082-3384 kem_6960119pcf_dec 0 226 326647 +17292+923+0+454+608+335+256+459-400-58-344-658-295-155-295 kem_6960119pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair 1 1047319 236682812 +93028+236099+0+78004-50468-72407-135813-88407+62508+120687-57079+10091-25501+27941-74281 kem_6960119pcf_enc 1 226 164462 +2147+2610-2480+10112+12971-3162-134-2558-2582+0+321-2799+2423+19228-2598 kem_6960119pcf_dec 1 226 295172 +10876+1360+656-150-112-42+154-186+208-54-108+216+0-50+1065 kem_6960119pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pcf_keypair 2 1047319 1382529064 +357496+300066+672937-126724-402031+781362-350209+89480-349967-176651-363657+123904-661020+0+209148 kem_6960119pcf_enc 2 226 423135 -1607+3033-9209+159353+10173+9462-10237-10448-10312-1031+27203+45744-10878+17490+0 kem_6960119pcf_dec 2 226 2480872 +32365+6573+5623+1547+0-1035-371+367+737-1062-1204-398-1100+315-1839 kem_6960119pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair 3 1047319 728933230 +0+13456+220825-51398-25342+8136-61974+44359-26731-37629+65004-66929-83255+57618+120438 kem_6960119pcf_enc 3 226 155587 +34733+55733+0+52819+17122-827+33860+16107-872-620-736-598+24757-914-16 kem_6960119pcf_dec 3 226 1869916 +36127+7691+4691+2067+1570+379-489-2323-1053+812+0-432-1515-169-2007 kem_6960119pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6960119pcf_keypair 4 1047319 1405921230 +139789-10343+71267-298537-268849+0-82833-73817-1503-42569+200710+14609+51505+7403+1044448 kem_6960119pcf_enc 4 226 423791 +69681-289+63+8855+0-9312+805-10467+130268-9885+53867-9398-9406+9043-9130 kem_6960119pcf_dec 4 226 2559843 +34273+7677+6096+6361+2004+1384-115+0-233+607-1510-907-1518-2219-985 kem_6960119pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6960119pcf_keypair 5 1047319 826942994 +51564609-132875-59821+182299+663735+82241+0-89952+48084-64057-95334+221785-128147-55305+410032 kem_6960119pcf_enc 5 226 241445 +23165+67501+0+28441+24769+17160-820+8366-504+7725-780-482-569-3676-802 kem_6960119pcf_dec 5 226 2036441 +26643+6761+4653+771+1039+543-8-294-529+798-963-402-1065+0-968 kem_6688128 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair selected 1044992 454129351 +137715-91145434+274588318+548834976-182616955+92158899+227095+291506-182709306-91266167+0+283932-182538000-182703924-91080176 kem_6688128_enc selected 208 136549 +5793-4604+3643+37317-666+2965-5724+19013-5356+0+2790-2685-6110+19129-2824 kem_6688128_dec selected 208 300308 +21076+2126+422+468-31+0+123+87-110-172-191-150-222+90-253 kem_6688128 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128_keypair 0 1044992 435972277 -100510673+402112180-100556513-59153+100662643+100451956-100617259+703721450+0+402092009-166538-100718349+703965718+603353675-100552001 kem_6688128_enc 0 208 184287 +0-12847+9030+12101-12956-13093-13328+5699+11808+9819-9441+690+78-9599-12484 kem_6688128_dec 0 208 331470 +18262+1943-38+1011+181+162+679-663-809-533-1124+0-1054-567+2320 kem_6688128 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair 1 1044992 454424502 -91588745-182822182-91402827-91356820+182841210-91585396+28716-91428873+91394163+365864704+0-91757406+12284+182656051+457457037 kem_6688128_enc 1 208 136364 +17704+7098-2133+11025-4680+4554+494-5330+0-5735-4847-5237-5155+10934+23673 kem_6688128_dec 1 208 300126 +12618+1629+699+290+0-50+246+60-102-72+124-188-131-45-6 kem_6688128 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128_keypair 2 1044992 3032180571 -621270332-1110877730+847224539+846903525-1110942202+1336804797-621546831+2315546444-1110972225+846947849-1600366099+0+6231661330+2805058714-131718799 kem_6688128_enc 2 208 397636 -9600-3749+33517-18910+22034+0+70400-8873+11507+39855-19416+140719-18498-19939+1200 kem_6688128_dec 2 208 2546514 +36803+9274+4710+3299+3020+705+1924-211+0-91-1548-375-667-2018-2368 kem_6688128 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair 3 1044992 1241228320 +488558745-488264269-244071434+244268857+244216574-51159-488320663+0-488236330+5615410399+289250494+488452586-244227858+488255864-61997 kem_6688128_enc 3 208 140339 +54660+66896-381-1071+8191-44+35509+18557-770+8517+75098-716+0-42-1244 kem_6688128_dec 3 208 1930290 +44489+7465+2448+3340+407-184+204-62-621-1383-1758+464-1174+0-372 kem_6688128 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128_keypair 4 1044992 2503917947 +2577241902-1029100753+377472-511542337+3089582051+1030724840-514583947-1029008085-515997886-1029070665+0+1030114988-515345032+59225+6179960135 kem_6688128_enc 4 208 401968 +67970+0-22210-12158-1283+10017+9409+73843-20198+32165-22321+20267-11119+41694-22485 kem_6688128_dec 4 208 2612470 +39452+16365+8725+8228+12415+374-836-858+0+2221-552-1082-313-3859-524 kem_6688128 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128_keypair 5 1044992 1467813639 +285276839-285454634+1711691756+0-570547315+1996951762+285493215-285120380+1426142739+570806058-570841124-569350212-294537-285327406+570803521 kem_6688128_enc 5 208 203928 +37314+1063-10635+51947-10280-10553+9841+9665-21050+30632+0-10733-21494-11440+9805 kem_6688128_dec 5 208 2013954 +34429+4516+2843+2619+658-345+214-718-798-910-210-790-124+0+924 kem_6688128f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair selected 1044992 271882924 +0+110239-40398-89223+102669-110947+19434+37001+51349+36709-85372-42115-80121-154348+57220 kem_6688128f_enc selected 208 133601 +3212-2138+677-2710+11152+18400-2633+8083-3032-2919-2920+22208+0-9+5599 kem_6688128f_dec selected 208 300471 +19777+1574+846+6-152+0+121-225-354-10-143-115+1511+1108-244 kem_6688128f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128f_keypair 0 1044992 339137981 -91883+47495-66957+21014-70321+0-1366+11752+80302-33250+11027+93847-92112-15875+84541 kem_6688128f_enc 0 208 177500 +10550-6395-6065+612+252-6211+6436-6197+5760-6751-2358+595-1798+3237+0 kem_6688128f_dec 0 208 331013 +16190+1302+1132+1023+1316+559-869-493-241-438-882-620-671+198+0 kem_6688128f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair 1 1044992 271881864 +56135-96374+47314-14102+263912+26458+55680-163162-153896-55072+196541-81466-165043+0+145828 kem_6688128f_enc 1 208 133507 +1116+6804+2797-2275-151-2661+2627+659-2757+3002-2274-52+0-2921+356 kem_6688128f_dec 1 208 300136 +12456+2098+547-121+101-19-207+0-349-83-146+6+192+4-235 kem_6688128f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128f_keypair 2 1044992 1523150083 +1289215+440528+351445+1614749+41511+0-253079-405281-471242-50730+485318-87848-157713+196277-106106 kem_6688128f_enc 2 208 388303 +83899-9820-74-9938+10660-692+39600+19613+0-10129+11209+395-10245+60785-10289 kem_6688128f_dec 2 208 2547746 +34191+9703+2793+1754-740-769+0+946-536-1982-2647-2286+708-888+807 kem_6688128f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair 3 1044992 780024541 +125685+155659+0+35951+59488+114225+89927-83902-82446-26877-56557+38089-12467-111598-66196 kem_6688128f_enc 3 208 159111 +53963+76615+9955-9887-834+28920-18412+9232+0-10597-20001+65861+153375-19833-9156 kem_6688128f_dec 3 208 1929201 +36659+6880+2677+1455+1366+618-106-169-1164-467-620+1161+0-561-971 kem_6688128f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128f_keypair 4 1044992 1545681752 +1091058+369628+170810+216154+412914-361287-67334-251100+0-699899-316311+154557-111260-479336+1003538 kem_6688128f_enc 4 208 391601 +123088-1241+0-11194+42013-1025+9894-12338-11916+65292+31151+8691-12112-11356+31361 kem_6688128f_dec 4 208 2617800 +33708+6786+4774+4401+1861+2750+3689-1477-3890-3577-1106-1837-2353+0-2090 kem_6688128f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128f_keypair 5 1044992 889310561 +64126-71537+52606+73191+29703+0-51813-121581-39561-59909-83562-117179+23734+64168+111657 kem_6688128f_enc 5 208 203625 +3390-21217+1624-10552+20388+10365+0-23652+71728+29193-2261-13258-1733-23502+37909 kem_6688128f_dec 5 208 2014031 +29418+6489+2468+401+327+1801-585+1178-1054-1310-1409-61+0-2187-1519 kem_6688128pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair selected 1044992 454523620 +457408025-183006048+274379349+366302564-183147912-289938-183121966+0+182961479-182973380+50454-183111791+91505641-183086598+96963 kem_6688128pc_enc selected 240 150719 +11354+210-3170+2349-5990-5886+3020+15317-6430+4998-571-5780+5563-3239+0 kem_6688128pc_dec selected 240 311354 +14188+2041+665+104+178+7-189-234-28+133-79+0-49-99-25 kem_6688128pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pc_keypair 0 1044992 435803886 +0+1206553904+73703-100447020+804391512-100296596-100374799+301696150-100391236+175505-100404137-100487774+204903-100375787+100647347 kem_6688128pc_enc 0 240 189740 -3301+9971+6366-3362-6571+21872-6574+3281+0+5679+19583-7041-6785+5877-7194 kem_6688128pc_dec 0 240 342757 +17088+2109+959+400+357+3113-343-373+0-162-197-403-265+102-207 kem_6688128pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair 1 1044992 454330896 -91505609+366372006+0-91062273+91523971+91716988+276880+60851-182836251+91732474-182823008-67928-182940984-182920113+274478723 kem_6688128pc_enc 1 240 153139 +1373+13881+13233-152+48-8074-8098+0-5556-2669+29842+1712-8392+52-8114 kem_6688128pc_dec 1 240 311543 +11955+1869+598-137+104+0+32-15+51-85-247-245-287+62-88 kem_6688128pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pc_keypair 2 1044992 1921776900 -489558459-80055-489925511+489725032+489789239+0-489369182-489718723+1112191365+1469334102-200334+490238725+979591307+979405347-489886609 kem_6688128pc_enc 2 240 392722 +19174+41607+0-1653+37370+65826+47240-3670-3383+36812-2668+6519-3464-1695-2738 kem_6688128pc_dec 2 240 2556674 +33449+6367+3186+2374+2504+1154+0-2639+1224-4241-1060-1112-4179-3893-2321 kem_6688128pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair 3 1044992 995713130 +194261-243494886-61067+0-243359586+1946839904+973501707-243276362+486744933-113947-243340505-243389655+243382628+1703510354+243259600 kem_6688128pc_enc 3 240 170763 -6968+25934+39557+989-18303-9186-18906-18584-18676+38501+28435+618+0-6956+9489 kem_6688128pc_dec 3 240 2250412 +35849+7457+3297+1079+1398+2055+1140-556-588-810-1063-1084+0-1115-1092 kem_6688128pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pc_keypair 4 1044992 1988920067 +517681107-512632517-514411195-513578270+1546092019+2061437785+2576729521-513586070+2577852101+1160141-513737769+0-513943925-513612994+1032898280 kem_6688128pc_enc 4 240 434333 +26333+23800-12836-46104+50646-2177+8095-43038+11226+9703-42551+0+10490-32466-43676 kem_6688128pc_dec 4 240 2625873 +33993+10831+6706+3149+2343+3930-763-219-1956-2401-427+0+48-4136-3651 kem_6688128pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pc_keypair 5 1044992 1182482552 -5026-285187443+285448546+7726-285182478+52815-285221861+740820+225947+104212+0-285029049+285453445-122817-285379209 kem_6688128pc_enc 5 240 217038 -6485+306+0-3429+15446+14424-6752+17219+59039-7450+25207-7020-17227+12402-8534 kem_6688128pc_dec 5 240 1976448 +32042+5027+3699-405-29+1624+3126-787+0-1817-212-1354+224+1985-1279 kem_6688128pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair selected 1044992 271840417 +44091+100091+54754+72468-215486+0-79951-24043-8449+63182-229620-129464-19729+21721+80689 kem_6688128pcf_enc selected 240 149203 +0-4403-4034+11746-1682+4279+18917-4074+3360-1570-1326-4338+20190+4348+1786 kem_6688128pcf_dec selected 240 311528 +15532+2053+549+174-134+0+2696+4-31-337-240-54+32-81-184 kem_6688128pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pcf_keypair 0 1044992 339353731 +0-10382-76917+205725+64906-85689+115919+23323-86250+115391+3886-128985-185136+33355-62082 kem_6688128pcf_enc 0 240 189144 +0+22431+2832+2667-3306-6985+9882-7381-6647+8949-3640-6344+3320-6780+803 kem_6688128pcf_dec 0 240 342602 +16629+2782+576+692+562+628-284+306-190-644-548-264-842-630+0 kem_6688128pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair 1 1044992 271849920 +13094-31126-52510+33392+91007+70594-154403+280308-61143-103885+0+184972-99377+24530-9594 kem_6688128pcf_enc 1 240 147905 +11620+3544+10516+11326+4848+0+106-2914-508-3037-3148-3006-3037+24308-744 kem_6688128pcf_dec 1 240 311543 +11121+1831+743+332+122-125-311+1872+1003+0-185-62-326-347-245 kem_6688128pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pcf_keypair 2 1044992 1522522506 +254537+139082-497251+0-263969-358391-126099+279938-30390+1744946+5893-92983-134674+285649+606159 kem_6688128pcf_enc 2 240 409463 +35982+21664-16748+0+9815-445-10502+859+59461-20349-8973+9758-10322+30127-116 kem_6688128pcf_dec 2 240 2559453 +36071+7950+7384+1320-423-1495+1880+0+2394+1152-1260-2635-119-1482-1122 kem_6688128pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair 3 1044992 780357668 +42955+117489+145839+0+159172+63122-36610+26650-71513-23565-88613+62770-76528-125902-65100 kem_6688128pcf_enc 3 240 171458 +65118-19319+77084+0-19820+9105+9289-512-9890-19288-19569+7532+312+28926-19008 kem_6688128pcf_dec 3 240 2250415 +36627+6577+7475+1873+975-1034-998+0+38+17-1161-983-668-121-1162 kem_6688128pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_6688128pcf_keypair 4 1044992 1546757930 +524492-438373-469676+330453-145780-209868+108679+9226-126920+1206874-300016+2189+353671-290448+0 kem_6688128pcf_enc 4 240 412244 +25981+13197-20457+11916+31694+9173-24747+40115-10010-10181-10889+0-21461+1048-11253 kem_6688128pcf_dec 4 240 2629847 +37183+6923+4988+492+2352-2004-66-482+211-1277-3447-2382+1395+0-3346 kem_6688128pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_6688128pcf_keypair 5 1044992 889673989 -43674-8243-85153+55205+352210+61667+255708-111924-44862+0+161200+175769+70425-145228-8441 kem_6688128pcf_enc 5 240 221314 -10083-17390+12617+22446-21710-781+30977+20556+0-2555+7728-23885-23267+49816+8415 kem_6688128pcf_dec 5 240 1976502 +29249+5930+2957+4303+1580+84-1911+0-1486-1486+87-490-2399-1801-1372 kem_8192128 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair selected 1357824 487952422 -182898531-91546989+1372529934-182880498-183018403-182893830-13124+732444274+182850043+0-182812852+91629152+353430+91665694+183161759 kem_8192128_enc selected 208 166021 +6271-1203-909-883-1067-436+3631+67+661+5098+1023-1105+746+0-88 kem_8192128_dec selected 208 304204 +22604+1588+690+172-90+214-176-182+0-176-226-214+118-102+0 kem_8192128 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128_keypair 0 1357824 656248093 +195175058-259850406+195796642-293923013+0-265276306-95021594-295039173+202758206+1080862645-932384+488983670-294907467+96983575+313751333 kem_8192128_enc 0 208 224324 +521-1649-2192+5883+3302-2786-2737-1465-701+10692+1616+631+2408+0-2040 kem_8192128_dec 0 208 351027 +23885+4657+331+543-824+476-130+92+0-1038+243-1025-563-1353-416 kem_8192128 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair 1 1357824 396622673 +464525-91696929+823034190-91452438-91455127-91606819+457258209+182834648+91612765-91417784+53578-91366541-91399846+0+182665367 kem_8192128_enc 1 208 167326 +3937-133+89+1065-123+2436+2180-1766-2100-2014-2424+0-2637+3117+3975 kem_8192128_dec 1 208 304122 +28036+2640+896+301+193+0-44-340-403-81-208-53-316+2732+456 kem_8192128 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128_keypair 2 1357824 2057921838 +1461641203-487544345-487406758+487235855+486932276+0-141371+487919540+1949374949-487055392+1948936406+2436147307-314674-486952732-487331756 kem_8192128_enc 2 208 476356 +25120-13710-7297-15235-16206+25852+676-15885+26198-7421+16429+16198+0+33282-635 kem_8192128_dec 2 208 2540485 +38680+7414+5008+1490+2151+388-2672+384+0-4082-1677-1432-795-1269-928 kem_8192128 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair 3 1357824 1205557218 +204583307+2249375012-204561194-204599612-408891071-409063248-408951775-409002965+204390974+204320333+204304568+1067748499+613590575-204454838+0 kem_8192128_enc 3 208 181914 +10135+6663+16591+0+30839-8840-635-8271+7446+23276+844-351-8729-1045-8735 kem_8192128_dec 3 208 1657703 +46087+7434+2635+744+387+0-995+1137-21-340-1677-545-1660+760-1877 kem_8192128 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128_keypair 4 1357824 2125366851 -517681681-518439393+519365573+5190232798-359928039+3113370653-518203082+2594329036+518602867-519296+1038318986-518264700+0-518656252+305222 kem_8192128_enc 4 208 479225 +19596-14997+956-7885-17713-9037+0+16978-9501+25154-9406+26261+25037-9243+17374 kem_8192128_dec 4 208 2579792 +33224+6789+5432+1770+2984+0-1338-1537-1363-1454+219-223-577+301-1049 kem_8192128 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128_keypair 5 1357824 1178317498 +263786710-399533-264032166+791797676-264043193-223788+263850869+263781272+1055581151+527901162+0-263908174-263974988+1584075088-263720259 kem_8192128_enc 5 208 213529 +77431+2224+0+8949-566-885-240+18918-86-105-284+8477-303+560+18116 kem_8192128_dec 5 208 1686314 +31807+5765+4556+1897+0+2544+249-698-267-815-444-1750-1049+1084-777 kem_8192128f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair selected 1357824 305522101 +35251+76813+85960+48214+0-8660-164229+26101-110834-132366-105866-88103+61641+51421-61879 kem_8192128f_enc selected 208 166149 +4152+4210-751+19-948-925-1237+0-994-1343+1234+323+2525-902+173 kem_8192128f_dec selected 208 304372 +18460+1818+658+3812-40+0+18-126-262-126+82-182-146+66-172 kem_8192128f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128f_keypair 0 1357824 366747892 -1306624-1279130-387577-1284394+40144961+38878505+36565892+39602726+37555827-3562-1284483+38760222+35906352+0-1236432 kem_8192128f_enc 0 208 213840 +14200+0+4877-524-184+2188-679-1221-168+789-809+4882+7450-119+276 kem_8192128f_dec 0 208 331506 +18246+1032+228+858+1463+2195-391-73-252-447+0-717-633+298-999 kem_8192128f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair 1 1357824 305551084 -1517+0+172601+103000+327294+161340-114255-63912-27867-45844-52292+40239+73972+6012-213190 kem_8192128f_enc 1 208 167301 +1721-1964-321-683+3319-1417-1920+3926+7200+1054-2324+1838+0-2346+827 kem_8192128f_dec 1 208 307612 +7902-2118+630+512+126+186+0-60-22+154+22-3520-152-170-3518 kem_8192128f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128f_keypair 2 1357824 1747729054 -828975-691274-644105-21272+0+383277+459460+1805697+261645-459158-251888-109373+51160+126737+294756 kem_8192128f_enc 2 208 468414 +32397-7555+18282+0+24865-794-8456-8670-5537+25027-740-8773+8056+7758+24123 kem_8192128f_dec 2 208 2543838 +34777+6000+1095+5995+140-1274+261-2282-2276+107-3006-3339+0-1823-346 kem_8192128f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair 3 1357824 827875900 +262233+54911-53919-33535+139130-8912+44477-9147+0+180472-55326+290011+375408-38761-26 kem_8192128f_enc 3 208 188652 +18518+1995-15073-15457-15409-15483+0+33523-15286+15829+15401+8167+7902-15999-7510 kem_8192128f_dec 3 208 1657308 +41102+6638+3043+1899+228+836+0+2433-168-197-1215-864-1010-792-731 kem_8192128f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128f_keypair 4 1357824 1817313918 -649738-539202-197188-372888+801032-313268-314919+472555+158333877+289765+757763-331+206475+332130+0 kem_8192128f_enc 4 208 486790 +9670+3284-22113-24680-7834+910-25877-7667-7266-25082+488+320+0+521+9415 kem_8192128f_dec 4 208 2580058 +30967+5789+6399+985+2845-1053-5450-2283+1138-1853-1333-5452+0+972-2253 kem_8192128f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128f_keypair 5 1357824 952854159 +0-64842-175643-220967-75190+59068-130958-69194-84083+40193+12447+655691+62360717+89189+6640 kem_8192128f_enc 5 208 231650 +16540-17293-9031-9693+35651+17345-600-9831+8985+72029-9809+35932+0+8081-18980 kem_8192128f_dec 5 208 1686833 +28113+6411+2824+423+1164-376+498-154+835-194-1335+0-842-127-1065 kem_8192128pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair selected 1357824 488157860 +60012+274159886+91531148+274258205+91673531-162361-91339809-41310-183013783-182922836+0+365936743-183025478+183222667-91523764 kem_8192128pc_enc selected 240 180352 +3067-2078-2017-2089+622+3883+4075+2999+760+0-1490-1561-1996-281+3749 kem_8192128pc_dec selected 240 319762 +15100-1314-2544+672+382+256+188+0+226+1409-2094-2984-3028-3070-3008 kem_8192128pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pc_keypair 0 1357824 752879986 -391562172-195825303-194782032-391680016+787864950+198554315+0+391673795+197206203+97848816-391595322-263949859+198590537-52925060+203190101 kem_8192128pc_enc 0 240 232896 +2694+4813-1219+7020-734+391-1844-1028+0+849+1183-736-1316-154+8443 kem_8192128pc_dec 0 240 343871 +16482+1412+2452-387+613+163-367+221+0-588-236-160-519-566+14 kem_8192128pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair 1 1357824 396612288 +274457921-91529373-87774-243679-91566420+182940705+274465601+731702385+640679624+274567977+91320030+0-91585264-91475529-91437191 kem_8192128pc_enc 1 240 180412 +2978+148-103-321-654+804+8-484+2411+5016-15-1981-2087+2152+0 kem_8192128pc_dec 1 240 316770 +12420+1702+820+282+294-12-40+62+8-356+0-138-144-184-354 kem_8192128pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pc_keypair 2 1357824 2058021289 -75084+0+487106272+2436045982+1461712202+487088094-487462901-486994139+1948745220+486856357-487383399-487127570-487380770-487323301+3898146043 kem_8192128pc_enc 2 240 490049 +39692+3065+10522-6802-16730+9846-16745+0-8006+8888+17892+26225-16789-8225-8356 kem_8192128pc_dec 2 240 2548515 +29834+6678+7433+1021-541-1905-656+590-2785-2105-2576+0-545+1760+729 kem_8192128pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair 3 1357824 1001098878 -43883-204621282+0-204683136-86947+408830754+204578000+215460-204620723+204456038-204601905-174292+154021+204418616+408858118 kem_8192128pc_enc 3 240 192976 +7697-3245+26370+9133-7625-7461+0+7817-7656-7552-7627-7615+7485+428+15643 kem_8192128pc_dec 3 240 1664322 +40628+6825+3199+0+569+282-145-1468+2764-557-965-1274+39-748-350 kem_8192128pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pc_keypair 4 1357824 2126051137 -518896507-518300992-785274+0-519288177-519351302+385278+1037541478+2076514800+3630584008+2075774334+4148088752+518522057-518649650-518272869 kem_8192128pc_enc 4 240 487401 +1009+4509+0-11897-3556+13995+5074-12896+22265+13707-12814-4258-13171+21846-13195 kem_8192128pc_dec 4 240 2594649 +31354+6353+3094+296-464+78-4011-2291+977-286-1252+0+180-2502-3412 kem_8192128pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pc_keypair 5 1357824 1178267618 +263869543+155503-263867094+263895523-263888526-264064251+263937550+1056295287-263937435+1319753833+54464-263902470+0-263823693-263517289 kem_8192128pc_enc 5 240 242028 +21149+4623+1005+9256+0-450-419+8507-9675+80423+44126-623-9628-8881-9089 kem_8192128pc_dec 5 240 1702221 +29914+6646+4741+1718-147-473+849-470-515-1099+1780+77-1107-266+0 kem_8192128pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair selected 1357824 305551539 +83558-92809+24531-113535+144564+0+12183-8789-16426+9198-109006+50639-223157-176561+82469 kem_8192128pcf_enc selected 240 180670 +3583-787+7736+2901+0+10246-406+2208-1025-454+379+3592-2443-1968-1185 kem_8192128pcf_dec selected 240 317296 +16972+980+0-318+1563+496-150-354+3098+2922-762+2866-460-618-658 kem_8192128pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pcf_keypair 0 1357824 366571914 -1322033-1345530+38281876+39454891+39589979+39643491+37981872+0-1322283-1279894-1245957-1281413+38719469+171039-1352053 kem_8192128pcf_enc 0 240 232907 +2623+1997+1898+0+6438-355+3858+9519-231-1402+1238-1501-1328-1726-1467 kem_8192128pcf_dec 0 240 343676 +17712+1332+300-242-90-56-572+0+96+28-50+484-444+278-372 kem_8192128pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair 1 1357824 305572381 +60245-3845+0+77376+82910+23429-101597-159324+133970-103146-128868-69724+37205+114838-26646 kem_8192128pcf_enc 1 240 180148 +1468+388+4127+0-1489-190-1213-620-326+509+1904+1448-449+397-474 kem_8192128pcf_dec 1 240 320068 +8384-1520-2668+622+246-3130+134+64-106+0+182+90-74-136-3436 kem_8192128pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pcf_keypair 2 1357824 1747540916 +250600-1032165+7010-26821-399861+37063+707597+0+691497+185678-582487+72328-987976-365974-890479 kem_8192128pcf_enc 2 240 482646 +78687+0+7574-9251-316-1072-1083+32824-8064+8458+16707-185+8142+7263-9523 kem_8192128pcf_dec 2 240 2557435 +35379+5338+4448+439+552+210-2270+1993-964-3917-1434-3975-1323+0-3369 kem_8192128pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair 3 1357824 827942548 +243467+80568-8776+20561-113014-10333+33829+18917+119394+0-39492-113196-21338+277198-76880 kem_8192128pcf_enc 3 240 194413 +6914+21984+563-6914-7774+0+8247+55208+39006+16016-268-544-8010-354-340 kem_8192128pcf_dec 3 240 1664694 +38753+7282+2731+2029+3544+190-571-734-130-367-157-638+1942+0-310 kem_8192128pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_8192128pcf_keypair 4 1357824 1817519408 -604163+0+313623-432564+637184-424881+189653-213409+22023+635178-266266+559504+170482-278274-494144 kem_8192128pcf_enc 4 240 484868 +50470+25186+7125-10430+7173-2022-9731+0-936-446+17881+42316-9711+25462-1680 kem_8192128pcf_dec 4 240 2593554 +33291+8887+5408+1463+3141+378+1923-802-1598+0-4590-2307-638-1787-2914 kem_8192128pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_8192128pcf_keypair 5 1357824 953083670 +183180+259850-101684-211841-111067-188844+369706-161012-254740+76949+138049+0+102849+74315-199686 kem_8192128pcf_enc 5 240 240820 +36893+12610+9831+1157-8431-8437+0-8812+135827-8126-8594+45756-5421+518-8880 kem_8192128pcf_dec 5 240 1702560 +29417+6013+3868+1249+1029+1894-1121+2016-624-172-186-1241-1607+0-1174 kem_460896 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair selected 524160 148097930 -37249608+74916360-37436056-176427+74845127+112214961-159861+186985047+0+149899989-37476875+74602431-37426006+97095-21275 kem_460896_enc selected 156 73431 +8498-788-1263-1281+23362-680+2993+3867+16554-191-1326-1410+21966+0+9477 kem_460896_dec selected 156 255796 +22425+1702+350-115+413-129+0+27-188+67-168-176-147-218+59 kem_460896 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896_keypair 0 524160 146129517 +133113857-16592-165337+0-216316+88624477+88572775+133088773+133174071-267355-41771-270955+88634566-112290+354750731 kem_460896_enc 0 156 100142 -3956-3902+663-9168+4755+17485+131+21593-3943+994-3704-8353+4643-3750+0 kem_460896_dec 0 156 284428 +18245+2000+494+572-340+720-234+25-409+0+225-548-435-556-180 kem_460896 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair 1 524160 185693930 -87932-37746958+261732702+112264838+0-37582524+37149695+37233552-141915+186851192-74994990-37522431-178477+149444888+74805678 kem_460896_enc 1 156 75842 +4121-3133-571-3227+8162-3015+4343-3893+296+32709-3204+113+0+3362-3677 kem_460896_dec 1 156 255712 +11367+1669+3660-48+210-227+133+0+93-54-43-26-164-21+183 kem_460896 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896_keypair 2 524160 984631269 +434184524+434146946-217167754+218069214+217102295-216651000-21708+217162579+868598639-217219794+2170976038+0-217200108-217280583-217255613 kem_460896_enc 2 156 212589 +72873+7484-1945+15571+6337-2552-3048+0+6762-1960-3097-1839-3055+26691+36611 kem_460896_dec 2 156 2291015 +38566+9952+5334+2931+1549+3726+1324-72-1557-903-584-383-449+0-640 kem_460896 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair 3 524160 532573806 +178252160+0+623888150-89435549+88992578-89382893+89060938-112863-89344107-89405669+88977712+178257817-89167223+89142757-158913 kem_460896_enc 3 156 89608 +107694+15874-119-8909-9299-7927+0+14277+7685-9391+14789-252+54978+217-8251 kem_460896_dec 3 156 1497942 +39834+6801+3637+2122+693+0+1899+342-509-1215-1035-1237-853-712-698 kem_460896 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896_keypair 4 524160 1012960946 +921879719+86735-220958504+230432560+230476833-231056957+309653537-230723013-230286835-230809014-230693335+691312785+1150969661+0-230335876 kem_460896_enc 4 156 220549 -1349-6509+2178-257+0+27578+26701-515+30088-594+27113+247-510+21437-9842 kem_460896_dec 4 156 2352287 +33366+8897+3116-110-3599+2027-2672+0-6008-5852+1509+199-1636+1083-3399 kem_460896 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896_keypair 5 524160 851301094 -124951828+1126423544+0+125471775-250214353+500977495-250321607+501032095-125191399+500648701-250234074+250434345+173675-125192373-125148118 kem_460896_enc 5 156 114046 +0+13313+8458-1106-10161+11461-290-10176+12242+32783-10449-1475+16062+15727-10493 kem_460896_dec 5 156 1523240 +34349+5842+468+452+1273+262-1731-561+1363-2148-1613-1203+0-2042-1606 kem_460896f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair selected 524160 111030475 +74828+25225+98314+94797-46956-17074-1559+31029-38016-58602+0-5595-76368+153438+42636 kem_460896f_enc selected 156 76230 +0-4267+3199-741+18020+3508-3873+3771-4391+4180+19424-3599-3233-58+25575 kem_460896f_dec selected 156 255863 +12641+1624+142+484+0-83+65-239-56+4-32+298-241-95-219 kem_460896f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896f_keypair 0 524160 147544527 +14411+106335-22012-71141+59966-148062-5649+0+63816-32961-3548+95368-47622+132614+17374 kem_460896f_enc 0 156 92193 +11574+16855+0-502+13566+8139+107-656+12322-171-1037-927+8237-825-266 kem_460896f_dec 0 156 284213 +14859+2496-31+471-191-507+0-370+23-244+186-397-641+315+571 kem_460896f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair 1 524160 111063966 -4341+54748-140320+0+8724+40401+41220-132312-61974-89339-36101+29266+54011+57682-7637 kem_460896f_enc 1 156 79959 -4017-7612-7786-7083+732-4436+4199+15575-7394+664+4151+0+6651+32709-4460 kem_460896f_dec 1 156 255790 +11910+1980+422-219+60-284+313+0-41+63-133-36-110+71-247 kem_460896f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896f_keypair 2 524160 786246248 +101417-41013-79739+50761-39097-89567+77814-49715+11876+58774+8364+0+178779-200773-88003 kem_460896f_enc 2 156 219701 -2003+62934+37484-361+2710+7528-1330-9626+0-8300-9684-676+699+16977+46759 kem_460896f_dec 2 156 2290727 +32947+8288+2296+3985+0-582-456-113+355+646+140-1200-1627-1127-1971 kem_460896f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair 3 524160 456960518 +292990-25072+47935+272024+40155+53064-25903-96910-8918-84787-58391+60812+14442-33467+0 kem_460896f_enc 3 156 81261 +52365-406+110+34171-292-890+0-366-714+8557+24481+15755+7799-290-664 kem_460896f_dec 3 156 1498570 +31516+6665+2549+1342+234+0+1065+128-895-759-580-1414-1502-1070-1190 kem_460896f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896f_keypair 4 524160 796086415 +185893+19469+342932-490911-139231-104353-406195+296692-247572+43728-425243-365862+746923+342904+0 kem_460896f_enc 4 156 221273 -1883+3675+1222-9063+18230-10904+64860-9009-146+0+17829+73807+26207-10497-1360 kem_460896f_dec 4 156 2349049 +31443+12137+2822+3922+4890+4428+916-1172-1408-2535+0-1554-131-469-2998 kem_460896f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896f_keypair 5 524160 520453475 +529315+120620+13679+153411-136119+0-86014-94460-184778+11042+16740-157546+107527-67103-60465 kem_460896f_enc 5 156 104697 +37924-110+27352+0-814-1760-741+23854+8313-86+20390+70551-1160+16867-608 kem_460896f_dec 5 156 1522095 +29268+7547+3513+5749+943+1549-1261-540-163-208-1128-745+1184+0-1289 kem_460896pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair selected 524160 148172594 +74924097-37533356-150391+37297804-183440-202431+0-37582979+149675145+37314750-136695+74615716+37196825+37282498-97730 kem_460896pc_enc selected 188 84269 +1265+27833+7547+342-3126+450-3715-3258+354-3223+0-3506-3454-3484+4027 kem_460896pc_dec selected 188 263904 +15408+1569+566+77-115+0-189+179-58+61-4-303+74-185-352 kem_460896pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pc_keypair 0 524160 279318198 +44259499+177612891-133273380+133145576+88684535-133197073+0-88929341+44202971-44540617-133199541-74233+6865681+88690619-44587904 kem_460896pc_enc 0 188 109081 +21563-4204-4602-9107-8555+16414-8726+4898+371+3950-9136+4840+0-4235+4013 kem_460896pc_dec 0 188 292808 +16493+2326+722+434-334+22+0-856-536-230-206+570+174-292-144 kem_460896pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair 1 524160 297767014 -187045142+74765213+74805622+149619093+37451027+0-149711014+74758327-187187889-149736585-149569937-149640796-37440088+37369261+37346487 kem_460896pc_enc 1 188 84848 +9+22196+14943-4034-760-3675-869+7021+13978-3718+14660-4233-83+4218+0 kem_460896pc_dec 1 188 263897 +11284+961+523-88+205-133-33-358-94+17+0+184+92-298-255 kem_460896pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pc_keypair 2 524160 984824967 +1085361582-72077+3256616740+0-92045-266036-210305+433936328-227005+868153779-313604+216757427-217518965+433782+652748476 kem_460896pc_enc 2 188 234845 +0+14351+22449-17148-17165-17567-17011+10146-17342+9619+10635+39884-7561-16775+15569 kem_460896pc_dec 2 188 2296952 +31201+7596+2717+4771-61+605+347+1123+0-9-56-853-221-658-1127 kem_460896pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair 3 524160 532450098 +89320727-89187085+0-89246845-49037+624289169+89303977+178332846-89214110-89198225-89183253+624144956+89185900+624220943-89138697 kem_460896pc_enc 3 188 104028 +6212+29455-6196+8978-15835+36570-7817-15567+8981-16311+558-16005-16157+24471+0 kem_460896pc_dec 3 188 1505143 +36903+7126+4044+726-49+1464+347-80+101-481-584-484-74-271+0 kem_460896pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pc_keypair 4 524160 1013898936 -212785022-230042527-682230+9072284-1605140-231523709+3715068-231275668+920276032+1840969962+228994863-227536195+536188+2765685530+0 kem_460896pc_enc 4 188 237496 +13226-17642-18674+8630+18962-18351+10083+62096-44+0-10053+8781-19051+18012-20954 kem_460896pc_dec 4 188 2359100 +31122+7672+4816+3011+3240+0+1685-3176-3720-903+963-3025-1381-4198-4126 kem_460896pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pc_keypair 5 524160 851371094 +501040613-250378061-125108148+500804377+561340+625971299+278579025+626113405+501122792-125103975+0-125107933-250375609-45636-250288987 kem_460896pc_enc 5 188 128734 +4781+16175-7605+38367-8288-16498-7402-17159+0+18031+34595+9033-8815+8798-16284 kem_460896pc_dec 5 188 1529601 +30871+6768+2903+4086+951+342-89-442-1034-925-107-294+1426-154+0 kem_460896pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair selected 524160 111064563 +27137+6154+31040-44782+0-22235+20993-16170+31675+44388-41765-7443-23920+8303-102 kem_460896pcf_enc selected 188 85070 +8370+331+0-4153+6245+3625-778-1621+21016+5913-383-3959-3885+6522-952 kem_460896pcf_dec selected 188 264014 +12703+1650+544+462-222+85-337-442+96-307-94+50-369-34+0 kem_460896pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pcf_keypair 0 524160 147561798 -75256-5374+68638+73294-8193+62822-140126+14469+25786+66086+0-71277-3817-43893+30460 kem_460896pcf_enc 0 188 108327 +9584-3131+590+0-252-7520-4276-3616+9189+5609+13029-3823+593+5141-7803 kem_460896pcf_dec 0 188 292794 +20289+3121+508+498-166+436-188+24-38+0-165+196-591-226-366 kem_460896pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair 1 524160 111053001 +10684-130135-74241+55814+27758+0-27165+41917-4997-53588-13432+20937+36533+185705-8180 kem_460896pcf_enc 1 188 88029 +4778-6856-6996+7495+7743-2747-6750-6962+8556+127+60290-7560-3+703+0 kem_460896pcf_dec 1 188 264158 +13378+1769+257-128+71-196+36+56-395+0-113-202+17-334-100 kem_460896pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pcf_keypair 2 524160 786312948 -46309+75427+56627-66174+0+227893-12207-104139-8083+3909-193010+497477+1741044+11689-184765 kem_460896pcf_enc 2 188 227043 +20340-7384+19706+416+14546+18608-9956-9615-9794-9567-9457-9380+27291+36681+0 kem_460896pcf_dec 2 188 2299879 +35659+9125+4010+1824+2095+0-1357-312-294-1830+659-1810-269+103-2304 kem_460896pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair 3 524160 456965968 +77996-68589-17632+142723+23114-21031-11355-40273+3452+29389+30166+2743-26132+0-10758 kem_460896pcf_enc 3 188 88899 +85262-581+0-174+24066+8335-224-800+56855-988+55121-248+132836-433+7641 kem_460896pcf_dec 3 188 1504974 +36374+7817+4770+2513+1068+662-278+1872-428+0-539-925-501-429-1163 kem_460896pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_460896pcf_keypair 4 524160 795906297 -112469+87595-41937+685631-225059+329538+196298+0+175139-228048-267736+220271-53980+336385-57860 kem_460896pcf_enc 4 188 232703 +7512-1475+6612+6130-4195-13326+3434+26561-4092+0-13087-4931+4753-13824+18715 kem_460896pcf_dec 4 188 2358707 +30778+8309+5948+4545-41+166-3278+2632-3499-292+0-4713-2146+2342-4115 kem_460896pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_460896pcf_keypair 5 524160 520312916 -102886-310972+428000+0-182925+32444+271737+29915-192978+43468-88487-376619+26324+78476-12317 kem_460896pcf_enc 5 188 113657 +8638+1504+0+21532-1242-1273-1863+24835+15843-1605-1967+16295-1561-1964+15927 kem_460896pcf_dec 5 188 1529154 +31720+6160+3784+1238+0-126-42+2027-1352-139-75-1200+441-908+295 kem_348864 selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair selected 261120 55128610 -10418838+115162853+20902056-10447484-10491462+24520+47382+19314-20981231-20965459+0+20931461-20981014+41814267-20956871 kem_348864_enc selected 96 36335 +8316+2510-71+1572+87-134-226-22-81+1372-190+0-80+18+186 kem_348864_dec selected 96 121743 +24463+1252+401-335-315-341+243+0-554+31+151-293-531+142-292 kem_348864 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864_keypair 0 261120 55255092 +38256305-2623+38195797-12757479-49980+47923-12749660+12798407+38270768+12728845+38265154-12817111-49434+0-25089 kem_348864_enc 0 96 50483 +3398+679+91-2368+296-628-1806+917+5644-1695+0-1957-22+4348-375 kem_348864_dec 0 96 142858 +16711+1379+253+623+67-257+155-252-15+0-215-418-139-286+69 kem_348864 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair 1 261120 65575796 +83567-31377327+73234026+27173-10447483+41904334-10468854-31392274+34299-10416386+20980888-31404106+0+10412473-20879683 kem_348864_enc 1 96 37080 +3323+0+3571-785-587-856+1808-1185+1869-1019-877+6019+715+1056-833 kem_348864_dec 1 96 121837 +7551+1132+0+104+43-326-58+39+53-440-140-367-499+96-552 kem_348864 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864_keypair 2 261120 286164831 +43996124-55450039+43697685-5909699+44179592-5950394-5977139+291330531+43665654+215754697+0-55539907+43586828-55410842-55525748 kem_348864_enc 2 96 110944 +7001+1829+443+210-89-764-635+3814-908+0+3782-771-1633-1589+2468 kem_348864_dec 2 96 844702 +34672+9300+3509+1576+1348+23-281-703-474+0-200-202-647+209-3 kem_348864 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair 3 261120 253501132 +102449433-34381622+0-34401330-118563-34440903+34300284+205401622-102808293-102803488+34173604+68507358+102649783-68579961+34295624 kem_348864_enc 3 96 44876 +7068-531+2382-3052+4547-3525+687-3338+133+0-3726-3707+4110-4061+14841 kem_348864_dec 3 96 560630 +29316+3998+752+2036+674+403+204-344-493-582-534-553+0-199-620 kem_348864 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864_keypair 4 261120 286630675 -50572212-237983+112248-52297317+52431033+261986761-38766+157072291-52652255+163606+262096152-312277+7152+0-52674567 kem_348864_enc 4 96 113714 +4267-337+2730+0+1470-929+1094+11711-1147-3265-3122-3006+1337+1145-3394 kem_348864_dec 4 96 871251 +34994+10363+5775+3507+2682+2631+639-274+0-103-146-236-262-516-163 kem_348864 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864_keypair 5 261120 234144850 +36196846+179329090-71914354-71956741+143406994-71936129+71667294+35646545-130362+0-81854+179309813+250930441-36369-36148746 kem_348864_enc 5 96 54316 +15224-25+0+4455+29365-1048-1529+6756+6197-1536-1523+6555-1891+10978-1583 kem_348864_dec 5 96 557532 +29314+3154+441+426+1329-413-50+86-158-242+0-160+22-52-174 kem_348864f selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair selected 261120 35195401 +51021+30463+52228+0-3384+14196+6176+16222+21575-20006-43686-19855-12961-16096-15691 kem_348864f_enc selected 96 36543 +5796+648-99+1442-321-41-370+3+50+0-215+3713-311+5606-198 kem_348864f_dec selected 96 121768 +9204+942+73+63+321-376+22-82+154+0-482-32-447-562-403 kem_348864f 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864f_keypair 0 261120 44249939 +50459-37208-36513+47889-8521-53510+58382-62420-55301+43856-23561+1231+44715+0+58982 kem_348864f_enc 0 96 48728 +5832+2107-255-192+1632+1573-141+2760+1570-179+0-151-204+1416-140 kem_348864f_dec 0 96 142775 +13295+2058+129+143-152+0+129-334-14-83-245+81-199+98-220 kem_348864f 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair 1 261120 35192163 +53093-16299+38843-37250-25923-38783+12727-45199-12442+9420+6865+38234-29487+24966+0 kem_348864f_enc 1 96 36585 +5949+2594-111+122+0-309-213+4066-26+1251-319-245-478+2709+3047 kem_348864f_dec 1 96 121709 +7615+907-360+209+142-14+186-348+160-395+0-304-345-295+36 kem_348864f 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864f_keypair 2 261120 246124593 +54629+207255-2548860-3916492-1926-3064443+34472-2644149+26789-27100+14270994-26419+11762+8569+0 kem_348864f_enc 2 96 114815 +8762-2626+5562-4048-4111+4216+24207+3962-4508-15-4850+4513-4832+0+246 kem_348864f_dec 2 96 844775 +29466+7673+3312+2178+574+0+0-386-188-843+43-398-350-147-249 kem_348864f 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair 3 261120 151992205 +49098-14982-22576+52284+31746+0+20736-13455+8377-692-50808+15987-8757-3817+38196 kem_348864f_enc 3 96 41773 +10429+2643+795+8730+4480-56+331-596+30387-532-774-450-356+0-162 kem_348864f_dec 3 96 559694 +21456+4398+511+214+386+127-270+99-577-308+0-215-155-527-98 kem_348864f 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864f_keypair 4 261120 249432434 +1049014-2155347-3874160+0-1269795+2148113+2014542-2008798+874195-334575-4057651+2436439+1598231+227875-845650 kem_348864f_enc 4 96 117456 +7207+0-6755-1638+7285-6512-6989-6449+2411+1824+1792+2086-7192-6565+1977 kem_348864f_dec 4 96 871950 +31881+10171+6395+3470+2267+682-183-128-653-235-121+0-441-259+53 kem_348864f 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864f_keypair 5 261120 167573941 +63026+35055-20526-16313+22296-38272-20552-33212-4976-15707+262660+84534+71843+21414+0 kem_348864f_enc 5 96 56641 +13435+3215+27772-4143-3806+0-758+4283+2976-3131-3191-3337+5673-480+5177 kem_348864f_dec 5 96 557471 +17340+3167+840+125+341+0+581+127-614-293-450-237-190-98-403 kem_348864pc selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair selected 261120 44650424 -10405860-10447083+73266888+73234146-10463285+41941898+38705-38096+20906869+10414475-48039-10477200-10508965+20959382+0 kem_348864pc_enc selected 128 45947 +7474+2297+0+52-181+1231-162-110+17-289+2742-223+49-47-49 kem_348864pc_dec selected 128 129746 +9927+1028+338-254+55+134-374-218-472+507+0-559-513+43-380 kem_348864pc 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pc_keypair 0 261120 55254219 +12807035+117921767+0+12790489+63753135-12723894-12760256-12704789+19642-12737604-12744509-12759041+8523+89260883-12766542 kem_348864pc_enc 0 128 57889 +3291+934+2034+53-133-1631-1260-1419+1594-1751+0+3069+241-1594-1069 kem_348864pc_dec 0 128 150729 +12993+1620+420+367+15+21-129+108-162-5-8-62-167-22+0 kem_348864pc 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair 1 261120 44613671 -10411027-10439478+20958159-10483321+20931769+0+50412-10418188+31390826-10382397+31396268+10467281-10483480+52323-10467103 kem_348864pc_enc 1 128 47125 +5739-913-1468+0+46+5434+149-1419-1277-1604+1162+314-1296+2977-1200 kem_348864pc_dec 1 128 129818 +8209+1133-141+205+110+194+78-261-312+0-260+36-50-336-91 kem_348864pc 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pc_keypair 2 261120 280218335 +449970-49492865+247730282+0+148581234+99208743+98997323+39435-49554383-49527374-49555277-49502215-49297040-49559069+99012992 kem_348864pc_enc 2 128 122907 +2747-2047+2253-2568-3855+318-4010+12357-4645+3621+3973+0-4423+7430-4665 kem_348864pc_dec 2 128 853220 +29121+6842+1999+1400+446-79-802-1086-570+0+94-360-359-593+536 kem_348864pc 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair 3 261120 184981997 +341911152-34335072+137048808+308055924+0+68376664-23602+34327140-62838-9475-34363478-37138-89446+34117451+34142514 kem_348864pc_enc 3 128 54553 +6215+12216+436+0+231-4163-4640-4564-352-4273-1004-4824+6238+3647+334 kem_348864pc_dec 3 128 567943 +23528+4210+1596+436+48+234+324-63+0-555-79-277-62-319-648 kem_348864pc 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pc_keypair 4 261120 338942182 -50176080+106236727-102685686+158970571-103674484+159222296-102830489-102891001-102670390+0+329196-103712346+159140923+263400037+286786 kem_348864pc_enc 4 128 119433 +7697+7351-323+0-966+3173+3772+7808+3192-1120+3179-966-1080-1219-970 kem_348864pc_dec 4 128 881245 +31680+9748+6728+5608+1916+435-550+200-277-344+0-906-424-642-291 kem_348864pc 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pc_keypair 5 261120 233987632 -71701486-35846982+0-35648567+36008388+71948979-35830950+72107069+107855989+36094178-35820767-35829300+35900942-71638629+72598 kem_348864pc_enc 5 128 63620 +13888+0-792-1110-1791+2689+2461-1948-1888+2819-2126-2254+2564+2496+2556 kem_348864pc_dec 5 128 566220 +17882+2561+800-698+492-233+388-308-658+174+528-38+0-98-563 kem_348864pcf selected implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair selected 261120 35207624 +42416+0-9785+6925-9650+7636+18773-1424+19971-20412-3369-32799+10756-86166+19718 kem_348864pcf_enc selected 128 46863 +3240-202+2151-967+0+1480+508-982-628+2869+1378+1334-1124-850-1172 kem_348864pcf_dec selected 128 129876 +8791+506-481-376-450-294-104+104-528+0+167+27+53+57-308 kem_348864pcf 0 implementation avx compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pcf_keypair 0 261120 44278576 +0-5044-15565-8434-120304+43963-49003-73710+21050+34150-60414+60814+4371+552+35723 kem_348864pcf_enc 0 128 56879 +3832+3963-643-262+7580+1610+1387-361-370+2706-475-275-801+0+1000 kem_348864pcf_dec 0 128 150842 +13407+2099+523+350+345-81+120-37-104+0-165-130-108-236+102 kem_348864pcf 1 implementation avx compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair 1 261120 35196889 -12233+48360-38646+9854+9296+94+35189+0-6336+27523+27598-22087-31992-24984-7330 kem_348864pcf_enc 1 128 47681 +1919+370+878+1058-270+3760-2021-447-1577+1353-361+1510-350+0-1924 kem_348864pcf_dec 1 128 129577 +8307+781+390+302-147-317+1679-209-279-306-374+21-362+0+94 kem_348864pcf 2 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pcf_keypair 2 261120 246137215 +157552+38180-6036118+53537-36071+19288+8044+0-30289-3205502+11887-53668-963293-25715+19965 kem_348864pcf_enc 2 128 123130 +8138-3431-4235+0-11+179+21191-849+32394+7528-4866-806+7443+3264-4920 kem_348864pcf_dec 2 128 854355 +30745+6908+3341+926+793+463+2316-331-222-166-234-492+0-332-491 kem_348864pcf 3 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair 3 261120 151990938 +9463-22589+1585+19876+15641+0-37365-14003-1644+1584-22854-33199-2311+16355+32139 kem_348864pcf_enc 3 128 54320 +5422-1950+1319+723+0-4096+11224-4765+7116+2399-3942-4322-4370-702+3486 kem_348864pcf_dec 3 128 568037 +21203+4294+1352+369-360-114+142+40+0+123-371-881-651-416-91 kem_348864pcf 4 implementation vec compiler gcc -Wall -fPIC -fwrapv -O2; gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0; Copyright (C) 2021 Free Software Foundation, Inc.; This is free software; see the source for copying conditions. There is NO; warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. kem_348864pcf_keypair 4 261120 251018502 -14682+1030112-2826895-514857+259054+4336161-1375657-509521+216706+1061626+2943664-1174205+0+2020058-634930 kem_348864pcf_enc 4 128 118865 +18627+743-18-534-526-251-295-276-212+0+12330+16582+3805+2377+13060 kem_348864pcf_dec 4 128 880416 +32013+9386+3966+2075+1065+955-49-105-299-71-173+102-344-22+0 kem_348864pcf 5 implementation vec compiler clang -Wall -fPIC -fwrapv -Qunused-arguments -O2; Ubuntu clang version 14.0.0-1ubuntu1; Target: x86_64-pc-linux-gnu; Thread model: posix; InstalledDir: /usr/bin kem_348864pcf_keypair 5 261120 167559943 +112921+332115-18741-22702-39258+47725-49561-11398-11787+20863+7743+0+21748-12421+299863 kem_348864pcf_enc 5 128 65265 +6500+0-2160+1562+1194+13994-3720+941-3217-3820-3597+5506-3785+4801-3781 kem_348864pcf_dec 5 128 566384 +17303+2970+509+656-552-108+0-321+82-646-187-186+6-35+205 libmceliece-20230612/command/0000755000000000000000000000000014441554466014341 5ustar rootrootlibmceliece-20230612/command/limits.inc0000644000000000000000000000042714441554466016340 0ustar rootrootstatic void limits() { #ifdef RLIM_INFINITY struct rlimit r; r.rlim_cur = 0; r.rlim_max = 0; #ifdef RLIMIT_NOFILE setrlimit(RLIMIT_NOFILE,&r); #endif #ifdef RLIMIT_NPROC setrlimit(RLIMIT_NPROC,&r); #endif #ifdef RLIMIT_CORE setrlimit(RLIMIT_CORE,&r); #endif #endif } libmceliece-20230612/command/mceliece-speed.c0000644000000000000000000016661614441554466017371 0ustar rootroot/* WARNING: auto-generated (by autogen-speed); do not edit */ #include #include #include #include #include #include #include #include #include /* -lcpucycles */ #include /* -lmceliece */ #include /* -lrandombytes */ static const char *targeto = 0; static const char *targetp = 0; static const char *targeti = 0; #include "limits.inc" static void *callocplus(long long len) { void *x = calloc(1,len + 128); if (!x) abort(); return x; } static void *aligned(void *x) { unsigned char *y = x; y += 63 & (-(unsigned long) x); return y; } #define TIMINGS 15 static long long t[TIMINGS+1]; static void t_print(const char *op,long long impl,long long len) { long long median = 0; printf("%s",op); if (impl >= 0) printf(" %lld",impl); else printf(" selected"); printf(" %lld",len); for (long long i = 0;i < TIMINGS;++i) t[i] = t[i+1]-t[i]; for (long long j = 0;j < TIMINGS;++j) { long long belowj = 0; long long abovej = 0; for (long long i = 0;i < TIMINGS;++i) if (t[i] < t[j]) ++belowj; for (long long i = 0;i < TIMINGS;++i) if (t[i] > t[j]) ++abovej; if (belowj*2 < TIMINGS && abovej*2 < TIMINGS) { median = t[j]; break; } } printf(" %lld ",median); for (long long i = 0;i < TIMINGS;++i) printf("%+lld",t[i]-median); printf("\n"); fflush(stdout); } #define MAXTEST_BYTES 65536 static void measure_cpucycles(void) { printf("cpucycles selected persecond %lld\n",cpucycles_persecond()); printf("cpucycles selected implementation %s\n",cpucycles_implementation()); for (long long i = 0;i <= TIMINGS;++i) t[i] = cpucycles(); t_print("cpucycles",-1,0); } static void measure_randombytes(void) { void *mstorage = callocplus(MAXTEST_BYTES); unsigned char *m = aligned(mstorage); long long mlen = 0; while (mlen < MAXTEST_BYTES) { for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); randombytes(m,mlen); } t_print("randombytes",-1,mlen); mlen += 1+mlen/2; } free(mstorage); } static void measure_sort_int32(void) { if (targeto && strcmp(targeto,"sort")) return; if (targetp && strcmp(targetp,"int32")) return; void *mstorage = callocplus(MAXTEST_BYTES); unsigned char *m = aligned(mstorage); long long mlen; for (long long impl = -1;impl < mceliece_numimpl_sort_int32();++impl) { void (*crypto_sort)(void *,long long); if (targeti && strcmp(targeti,mceliece_dispatch_sort_int32_implementation(impl))) continue; if (impl >= 0) { crypto_sort = mceliece_dispatch_sort_int32(impl); printf("sort_int32 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_sort_int32_implementation(impl),mceliece_dispatch_sort_int32_compiler(impl)); } else { crypto_sort = mceliece_sort_int32; printf("sort_int32 selected implementation %s compiler %s\n",mceliece_sort_int32_implementation(),mceliece_sort_int32_compiler()); } randombytes(m,MAXTEST_BYTES); mlen = 0; while (mceliece_sort_int32_BYTES*mlen <= MAXTEST_BYTES) { randombytes(m,mceliece_sort_int32_BYTES*mlen); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_sort(m,mlen); } t_print("sort_int32",impl,mlen); mlen += 1+mlen/2; } } free(mstorage); } static void measure_xof_shake256(void) { if (targeto && strcmp(targeto,"xof")) return; if (targetp && strcmp(targetp,"shake256")) return; void *hstorage = callocplus(MAXTEST_BYTES); unsigned char *h = aligned(hstorage); long long hlen; void *mstorage = callocplus(MAXTEST_BYTES); unsigned char *m = aligned(mstorage); long long mlen; for (long long impl = -1;impl < mceliece_numimpl_xof_shake256();++impl) { void (*crypto_xof)(unsigned char *,long long,const unsigned char *,long long); if (targeti && strcmp(targeti,mceliece_dispatch_xof_shake256_implementation(impl))) continue; if (impl >= 0) { crypto_xof = mceliece_dispatch_xof_shake256(impl); printf("xof_shake256 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_xof_shake256_implementation(impl),mceliece_dispatch_xof_shake256_compiler(impl)); } else { crypto_xof = mceliece_xof_shake256; printf("xof_shake256 selected implementation %s compiler %s\n",mceliece_xof_shake256_implementation(),mceliece_xof_shake256_compiler()); } randombytes(h,MAXTEST_BYTES); randombytes(m,MAXTEST_BYTES); hlen = 32; mlen = 0; while (mlen <= MAXTEST_BYTES) { randombytes(m,mlen); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_xof(h,hlen,m,mlen); } t_print("xof_shake256",impl,mlen); mlen += 1+mlen/2; } mlen = 32; hlen = 1; while (hlen <= MAXTEST_BYTES) { randombytes(h,hlen); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_xof(h,hlen,m,mlen); } t_print("xof_shake256",impl,-hlen); hlen += 1+hlen/2; } } free(mstorage); free(hstorage); } static void measure_kem_6960119(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119")) return; void *pstorage = callocplus(mceliece_kem_6960119_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6960119_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6960119_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6960119_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6960119_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119_dec(impl); printf("kem_6960119 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119_implementation(impl),mceliece_dispatch_kem_6960119_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119_keypair; crypto_kem_enc = mceliece_kem_6960119_enc; crypto_kem_dec = mceliece_kem_6960119_dec; printf("kem_6960119 selected implementation %s compiler %s\n",mceliece_kem_6960119_implementation(),mceliece_kem_6960119_compiler()); } randombytes(p,mceliece_kem_6960119_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6960119_SECRETKEYBYTES); randombytes(c,mceliece_kem_6960119_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6960119_BYTES); randombytes(T,mceliece_kem_6960119_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6960119_keypair",impl,mceliece_kem_6960119_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6960119_enc",impl,mceliece_kem_6960119_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6960119_dec",impl,mceliece_kem_6960119_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_6960119f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119f")) return; void *pstorage = callocplus(mceliece_kem_6960119f_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6960119f_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6960119f_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6960119f_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6960119f_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119f();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119f_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119f_dec(impl); printf("kem_6960119f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119f_implementation(impl),mceliece_dispatch_kem_6960119f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119f_keypair; crypto_kem_enc = mceliece_kem_6960119f_enc; crypto_kem_dec = mceliece_kem_6960119f_dec; printf("kem_6960119f selected implementation %s compiler %s\n",mceliece_kem_6960119f_implementation(),mceliece_kem_6960119f_compiler()); } randombytes(p,mceliece_kem_6960119f_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6960119f_SECRETKEYBYTES); randombytes(c,mceliece_kem_6960119f_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6960119f_BYTES); randombytes(T,mceliece_kem_6960119f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6960119f_keypair",impl,mceliece_kem_6960119f_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6960119f_enc",impl,mceliece_kem_6960119f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6960119f_dec",impl,mceliece_kem_6960119f_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_6960119pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119pc")) return; void *pstorage = callocplus(mceliece_kem_6960119pc_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6960119pc_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6960119pc_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6960119pc_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6960119pc_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119pc();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119pc_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119pc_dec(impl); printf("kem_6960119pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119pc_implementation(impl),mceliece_dispatch_kem_6960119pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119pc_keypair; crypto_kem_enc = mceliece_kem_6960119pc_enc; crypto_kem_dec = mceliece_kem_6960119pc_dec; printf("kem_6960119pc selected implementation %s compiler %s\n",mceliece_kem_6960119pc_implementation(),mceliece_kem_6960119pc_compiler()); } randombytes(p,mceliece_kem_6960119pc_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6960119pc_SECRETKEYBYTES); randombytes(c,mceliece_kem_6960119pc_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6960119pc_BYTES); randombytes(T,mceliece_kem_6960119pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6960119pc_keypair",impl,mceliece_kem_6960119pc_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6960119pc_enc",impl,mceliece_kem_6960119pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6960119pc_dec",impl,mceliece_kem_6960119pc_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_6960119pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119pcf")) return; void *pstorage = callocplus(mceliece_kem_6960119pcf_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6960119pcf_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6960119pcf_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6960119pcf_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6960119pcf_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119pcf();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119pcf_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119pcf_dec(impl); printf("kem_6960119pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119pcf_implementation(impl),mceliece_dispatch_kem_6960119pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119pcf_keypair; crypto_kem_enc = mceliece_kem_6960119pcf_enc; crypto_kem_dec = mceliece_kem_6960119pcf_dec; printf("kem_6960119pcf selected implementation %s compiler %s\n",mceliece_kem_6960119pcf_implementation(),mceliece_kem_6960119pcf_compiler()); } randombytes(p,mceliece_kem_6960119pcf_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6960119pcf_SECRETKEYBYTES); randombytes(c,mceliece_kem_6960119pcf_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6960119pcf_BYTES); randombytes(T,mceliece_kem_6960119pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6960119pcf_keypair",impl,mceliece_kem_6960119pcf_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6960119pcf_enc",impl,mceliece_kem_6960119pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6960119pcf_dec",impl,mceliece_kem_6960119pcf_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_6688128(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128")) return; void *pstorage = callocplus(mceliece_kem_6688128_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6688128_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6688128_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6688128_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6688128_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128_dec(impl); printf("kem_6688128 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128_implementation(impl),mceliece_dispatch_kem_6688128_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128_keypair; crypto_kem_enc = mceliece_kem_6688128_enc; crypto_kem_dec = mceliece_kem_6688128_dec; printf("kem_6688128 selected implementation %s compiler %s\n",mceliece_kem_6688128_implementation(),mceliece_kem_6688128_compiler()); } randombytes(p,mceliece_kem_6688128_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6688128_SECRETKEYBYTES); randombytes(c,mceliece_kem_6688128_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6688128_BYTES); randombytes(T,mceliece_kem_6688128_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6688128_keypair",impl,mceliece_kem_6688128_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6688128_enc",impl,mceliece_kem_6688128_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6688128_dec",impl,mceliece_kem_6688128_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_6688128f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128f")) return; void *pstorage = callocplus(mceliece_kem_6688128f_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6688128f_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6688128f_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6688128f_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6688128f_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128f();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128f_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128f_dec(impl); printf("kem_6688128f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128f_implementation(impl),mceliece_dispatch_kem_6688128f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128f_keypair; crypto_kem_enc = mceliece_kem_6688128f_enc; crypto_kem_dec = mceliece_kem_6688128f_dec; printf("kem_6688128f selected implementation %s compiler %s\n",mceliece_kem_6688128f_implementation(),mceliece_kem_6688128f_compiler()); } randombytes(p,mceliece_kem_6688128f_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6688128f_SECRETKEYBYTES); randombytes(c,mceliece_kem_6688128f_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6688128f_BYTES); randombytes(T,mceliece_kem_6688128f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6688128f_keypair",impl,mceliece_kem_6688128f_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6688128f_enc",impl,mceliece_kem_6688128f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6688128f_dec",impl,mceliece_kem_6688128f_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_6688128pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128pc")) return; void *pstorage = callocplus(mceliece_kem_6688128pc_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6688128pc_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6688128pc_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6688128pc_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6688128pc_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128pc();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128pc_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128pc_dec(impl); printf("kem_6688128pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128pc_implementation(impl),mceliece_dispatch_kem_6688128pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128pc_keypair; crypto_kem_enc = mceliece_kem_6688128pc_enc; crypto_kem_dec = mceliece_kem_6688128pc_dec; printf("kem_6688128pc selected implementation %s compiler %s\n",mceliece_kem_6688128pc_implementation(),mceliece_kem_6688128pc_compiler()); } randombytes(p,mceliece_kem_6688128pc_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6688128pc_SECRETKEYBYTES); randombytes(c,mceliece_kem_6688128pc_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6688128pc_BYTES); randombytes(T,mceliece_kem_6688128pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6688128pc_keypair",impl,mceliece_kem_6688128pc_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6688128pc_enc",impl,mceliece_kem_6688128pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6688128pc_dec",impl,mceliece_kem_6688128pc_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_6688128pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128pcf")) return; void *pstorage = callocplus(mceliece_kem_6688128pcf_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_6688128pcf_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_6688128pcf_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_6688128pcf_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_6688128pcf_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128pcf();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128pcf_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128pcf_dec(impl); printf("kem_6688128pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128pcf_implementation(impl),mceliece_dispatch_kem_6688128pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128pcf_keypair; crypto_kem_enc = mceliece_kem_6688128pcf_enc; crypto_kem_dec = mceliece_kem_6688128pcf_dec; printf("kem_6688128pcf selected implementation %s compiler %s\n",mceliece_kem_6688128pcf_implementation(),mceliece_kem_6688128pcf_compiler()); } randombytes(p,mceliece_kem_6688128pcf_PUBLICKEYBYTES); randombytes(s,mceliece_kem_6688128pcf_SECRETKEYBYTES); randombytes(c,mceliece_kem_6688128pcf_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_6688128pcf_BYTES); randombytes(T,mceliece_kem_6688128pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_6688128pcf_keypair",impl,mceliece_kem_6688128pcf_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_6688128pcf_enc",impl,mceliece_kem_6688128pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_6688128pcf_dec",impl,mceliece_kem_6688128pcf_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_8192128(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128")) return; void *pstorage = callocplus(mceliece_kem_8192128_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_8192128_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_8192128_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_8192128_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_8192128_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128_dec(impl); printf("kem_8192128 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128_implementation(impl),mceliece_dispatch_kem_8192128_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128_keypair; crypto_kem_enc = mceliece_kem_8192128_enc; crypto_kem_dec = mceliece_kem_8192128_dec; printf("kem_8192128 selected implementation %s compiler %s\n",mceliece_kem_8192128_implementation(),mceliece_kem_8192128_compiler()); } randombytes(p,mceliece_kem_8192128_PUBLICKEYBYTES); randombytes(s,mceliece_kem_8192128_SECRETKEYBYTES); randombytes(c,mceliece_kem_8192128_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_8192128_BYTES); randombytes(T,mceliece_kem_8192128_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_8192128_keypair",impl,mceliece_kem_8192128_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_8192128_enc",impl,mceliece_kem_8192128_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_8192128_dec",impl,mceliece_kem_8192128_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_8192128f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128f")) return; void *pstorage = callocplus(mceliece_kem_8192128f_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_8192128f_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_8192128f_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_8192128f_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_8192128f_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128f();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128f_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128f_dec(impl); printf("kem_8192128f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128f_implementation(impl),mceliece_dispatch_kem_8192128f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128f_keypair; crypto_kem_enc = mceliece_kem_8192128f_enc; crypto_kem_dec = mceliece_kem_8192128f_dec; printf("kem_8192128f selected implementation %s compiler %s\n",mceliece_kem_8192128f_implementation(),mceliece_kem_8192128f_compiler()); } randombytes(p,mceliece_kem_8192128f_PUBLICKEYBYTES); randombytes(s,mceliece_kem_8192128f_SECRETKEYBYTES); randombytes(c,mceliece_kem_8192128f_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_8192128f_BYTES); randombytes(T,mceliece_kem_8192128f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_8192128f_keypair",impl,mceliece_kem_8192128f_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_8192128f_enc",impl,mceliece_kem_8192128f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_8192128f_dec",impl,mceliece_kem_8192128f_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_8192128pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128pc")) return; void *pstorage = callocplus(mceliece_kem_8192128pc_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_8192128pc_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_8192128pc_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_8192128pc_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_8192128pc_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128pc();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128pc_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128pc_dec(impl); printf("kem_8192128pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128pc_implementation(impl),mceliece_dispatch_kem_8192128pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128pc_keypair; crypto_kem_enc = mceliece_kem_8192128pc_enc; crypto_kem_dec = mceliece_kem_8192128pc_dec; printf("kem_8192128pc selected implementation %s compiler %s\n",mceliece_kem_8192128pc_implementation(),mceliece_kem_8192128pc_compiler()); } randombytes(p,mceliece_kem_8192128pc_PUBLICKEYBYTES); randombytes(s,mceliece_kem_8192128pc_SECRETKEYBYTES); randombytes(c,mceliece_kem_8192128pc_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_8192128pc_BYTES); randombytes(T,mceliece_kem_8192128pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_8192128pc_keypair",impl,mceliece_kem_8192128pc_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_8192128pc_enc",impl,mceliece_kem_8192128pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_8192128pc_dec",impl,mceliece_kem_8192128pc_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_8192128pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128pcf")) return; void *pstorage = callocplus(mceliece_kem_8192128pcf_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_8192128pcf_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_8192128pcf_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_8192128pcf_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_8192128pcf_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128pcf();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128pcf_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128pcf_dec(impl); printf("kem_8192128pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128pcf_implementation(impl),mceliece_dispatch_kem_8192128pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128pcf_keypair; crypto_kem_enc = mceliece_kem_8192128pcf_enc; crypto_kem_dec = mceliece_kem_8192128pcf_dec; printf("kem_8192128pcf selected implementation %s compiler %s\n",mceliece_kem_8192128pcf_implementation(),mceliece_kem_8192128pcf_compiler()); } randombytes(p,mceliece_kem_8192128pcf_PUBLICKEYBYTES); randombytes(s,mceliece_kem_8192128pcf_SECRETKEYBYTES); randombytes(c,mceliece_kem_8192128pcf_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_8192128pcf_BYTES); randombytes(T,mceliece_kem_8192128pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_8192128pcf_keypair",impl,mceliece_kem_8192128pcf_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_8192128pcf_enc",impl,mceliece_kem_8192128pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_8192128pcf_dec",impl,mceliece_kem_8192128pcf_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_460896(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896")) return; void *pstorage = callocplus(mceliece_kem_460896_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_460896_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_460896_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_460896_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_460896_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_460896();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896_dec(impl); printf("kem_460896 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896_implementation(impl),mceliece_dispatch_kem_460896_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896_keypair; crypto_kem_enc = mceliece_kem_460896_enc; crypto_kem_dec = mceliece_kem_460896_dec; printf("kem_460896 selected implementation %s compiler %s\n",mceliece_kem_460896_implementation(),mceliece_kem_460896_compiler()); } randombytes(p,mceliece_kem_460896_PUBLICKEYBYTES); randombytes(s,mceliece_kem_460896_SECRETKEYBYTES); randombytes(c,mceliece_kem_460896_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_460896_BYTES); randombytes(T,mceliece_kem_460896_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_460896_keypair",impl,mceliece_kem_460896_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_460896_enc",impl,mceliece_kem_460896_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_460896_dec",impl,mceliece_kem_460896_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_460896f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896f")) return; void *pstorage = callocplus(mceliece_kem_460896f_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_460896f_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_460896f_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_460896f_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_460896f_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_460896f();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896f_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896f_dec(impl); printf("kem_460896f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896f_implementation(impl),mceliece_dispatch_kem_460896f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896f_keypair; crypto_kem_enc = mceliece_kem_460896f_enc; crypto_kem_dec = mceliece_kem_460896f_dec; printf("kem_460896f selected implementation %s compiler %s\n",mceliece_kem_460896f_implementation(),mceliece_kem_460896f_compiler()); } randombytes(p,mceliece_kem_460896f_PUBLICKEYBYTES); randombytes(s,mceliece_kem_460896f_SECRETKEYBYTES); randombytes(c,mceliece_kem_460896f_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_460896f_BYTES); randombytes(T,mceliece_kem_460896f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_460896f_keypair",impl,mceliece_kem_460896f_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_460896f_enc",impl,mceliece_kem_460896f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_460896f_dec",impl,mceliece_kem_460896f_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_460896pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896pc")) return; void *pstorage = callocplus(mceliece_kem_460896pc_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_460896pc_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_460896pc_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_460896pc_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_460896pc_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_460896pc();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896pc_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896pc_dec(impl); printf("kem_460896pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896pc_implementation(impl),mceliece_dispatch_kem_460896pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896pc_keypair; crypto_kem_enc = mceliece_kem_460896pc_enc; crypto_kem_dec = mceliece_kem_460896pc_dec; printf("kem_460896pc selected implementation %s compiler %s\n",mceliece_kem_460896pc_implementation(),mceliece_kem_460896pc_compiler()); } randombytes(p,mceliece_kem_460896pc_PUBLICKEYBYTES); randombytes(s,mceliece_kem_460896pc_SECRETKEYBYTES); randombytes(c,mceliece_kem_460896pc_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_460896pc_BYTES); randombytes(T,mceliece_kem_460896pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_460896pc_keypair",impl,mceliece_kem_460896pc_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_460896pc_enc",impl,mceliece_kem_460896pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_460896pc_dec",impl,mceliece_kem_460896pc_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_460896pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896pcf")) return; void *pstorage = callocplus(mceliece_kem_460896pcf_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_460896pcf_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_460896pcf_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_460896pcf_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_460896pcf_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_460896pcf();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896pcf_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896pcf_dec(impl); printf("kem_460896pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896pcf_implementation(impl),mceliece_dispatch_kem_460896pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896pcf_keypair; crypto_kem_enc = mceliece_kem_460896pcf_enc; crypto_kem_dec = mceliece_kem_460896pcf_dec; printf("kem_460896pcf selected implementation %s compiler %s\n",mceliece_kem_460896pcf_implementation(),mceliece_kem_460896pcf_compiler()); } randombytes(p,mceliece_kem_460896pcf_PUBLICKEYBYTES); randombytes(s,mceliece_kem_460896pcf_SECRETKEYBYTES); randombytes(c,mceliece_kem_460896pcf_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_460896pcf_BYTES); randombytes(T,mceliece_kem_460896pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_460896pcf_keypair",impl,mceliece_kem_460896pcf_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_460896pcf_enc",impl,mceliece_kem_460896pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_460896pcf_dec",impl,mceliece_kem_460896pcf_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_348864(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864")) return; void *pstorage = callocplus(mceliece_kem_348864_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_348864_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_348864_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_348864_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_348864_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_348864();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864_dec(impl); printf("kem_348864 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864_implementation(impl),mceliece_dispatch_kem_348864_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864_keypair; crypto_kem_enc = mceliece_kem_348864_enc; crypto_kem_dec = mceliece_kem_348864_dec; printf("kem_348864 selected implementation %s compiler %s\n",mceliece_kem_348864_implementation(),mceliece_kem_348864_compiler()); } randombytes(p,mceliece_kem_348864_PUBLICKEYBYTES); randombytes(s,mceliece_kem_348864_SECRETKEYBYTES); randombytes(c,mceliece_kem_348864_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_348864_BYTES); randombytes(T,mceliece_kem_348864_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_348864_keypair",impl,mceliece_kem_348864_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_348864_enc",impl,mceliece_kem_348864_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_348864_dec",impl,mceliece_kem_348864_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_348864f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864f")) return; void *pstorage = callocplus(mceliece_kem_348864f_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_348864f_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_348864f_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_348864f_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_348864f_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_348864f();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864f_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864f_dec(impl); printf("kem_348864f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864f_implementation(impl),mceliece_dispatch_kem_348864f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864f_keypair; crypto_kem_enc = mceliece_kem_348864f_enc; crypto_kem_dec = mceliece_kem_348864f_dec; printf("kem_348864f selected implementation %s compiler %s\n",mceliece_kem_348864f_implementation(),mceliece_kem_348864f_compiler()); } randombytes(p,mceliece_kem_348864f_PUBLICKEYBYTES); randombytes(s,mceliece_kem_348864f_SECRETKEYBYTES); randombytes(c,mceliece_kem_348864f_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_348864f_BYTES); randombytes(T,mceliece_kem_348864f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_348864f_keypair",impl,mceliece_kem_348864f_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_348864f_enc",impl,mceliece_kem_348864f_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_348864f_dec",impl,mceliece_kem_348864f_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_348864pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864pc")) return; void *pstorage = callocplus(mceliece_kem_348864pc_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_348864pc_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_348864pc_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_348864pc_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_348864pc_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_348864pc();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864pc_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864pc_dec(impl); printf("kem_348864pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864pc_implementation(impl),mceliece_dispatch_kem_348864pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864pc_keypair; crypto_kem_enc = mceliece_kem_348864pc_enc; crypto_kem_dec = mceliece_kem_348864pc_dec; printf("kem_348864pc selected implementation %s compiler %s\n",mceliece_kem_348864pc_implementation(),mceliece_kem_348864pc_compiler()); } randombytes(p,mceliece_kem_348864pc_PUBLICKEYBYTES); randombytes(s,mceliece_kem_348864pc_SECRETKEYBYTES); randombytes(c,mceliece_kem_348864pc_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_348864pc_BYTES); randombytes(T,mceliece_kem_348864pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_348864pc_keypair",impl,mceliece_kem_348864pc_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_348864pc_enc",impl,mceliece_kem_348864pc_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_348864pc_dec",impl,mceliece_kem_348864pc_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } static void measure_kem_348864pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864pcf")) return; void *pstorage = callocplus(mceliece_kem_348864pcf_PUBLICKEYBYTES); unsigned char *p = aligned(pstorage); void *sstorage = callocplus(mceliece_kem_348864pcf_SECRETKEYBYTES); unsigned char *s = aligned(sstorage); void *cstorage = callocplus(mceliece_kem_348864pcf_CIPHERTEXTBYTES); unsigned char *c = aligned(cstorage); void *kstorage = callocplus(mceliece_kem_348864pcf_BYTES); unsigned char *k = aligned(kstorage); void *Tstorage = callocplus(mceliece_kem_348864pcf_CIPHERTEXTBYTES); unsigned char *T = aligned(Tstorage); for (long long impl = -1;impl < mceliece_numimpl_kem_348864pcf();++impl) { void (*crypto_kem_keypair)(unsigned char *,unsigned char *); int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864pcf_implementation(impl))) continue; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864pcf_dec(impl); printf("kem_348864pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864pcf_implementation(impl),mceliece_dispatch_kem_348864pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864pcf_keypair; crypto_kem_enc = mceliece_kem_348864pcf_enc; crypto_kem_dec = mceliece_kem_348864pcf_dec; printf("kem_348864pcf selected implementation %s compiler %s\n",mceliece_kem_348864pcf_implementation(),mceliece_kem_348864pcf_compiler()); } randombytes(p,mceliece_kem_348864pcf_PUBLICKEYBYTES); randombytes(s,mceliece_kem_348864pcf_SECRETKEYBYTES); randombytes(c,mceliece_kem_348864pcf_CIPHERTEXTBYTES); randombytes(k,mceliece_kem_348864pcf_BYTES); randombytes(T,mceliece_kem_348864pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_keypair(p,s); } t_print("kem_348864pcf_keypair",impl,mceliece_kem_348864pcf_PUBLICKEYBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_enc(c,k,p); } t_print("kem_348864pcf_enc",impl,mceliece_kem_348864pcf_CIPHERTEXTBYTES); for (long long i = 0;i <= TIMINGS;++i) { t[i] = cpucycles(); crypto_kem_dec(T,c,s); } t_print("kem_348864pcf_dec",impl,mceliece_kem_348864pcf_CIPHERTEXTBYTES); } free(Tstorage); free(kstorage); free(cstorage); free(sstorage); free(pstorage); } #include "print_cpuid.inc" int main(int argc,char **argv) { printf("mceliece version %s\n",mceliece_version); printf("mceliece arch %s\n",mceliece_arch); print_cpuid(); if (*argv) ++argv; if (*argv) { targeto = *argv++; if (*argv) { targetp = *argv++; if (*argv) { targeti = *argv++; } } } measure_cpucycles(); measure_randombytes(); limits(); measure_sort_int32(); measure_xof_shake256(); measure_kem_6960119(); measure_kem_6960119f(); measure_kem_6960119pc(); measure_kem_6960119pcf(); measure_kem_6688128(); measure_kem_6688128f(); measure_kem_6688128pc(); measure_kem_6688128pcf(); measure_kem_8192128(); measure_kem_8192128f(); measure_kem_8192128pc(); measure_kem_8192128pcf(); measure_kem_460896(); measure_kem_460896f(); measure_kem_460896pc(); measure_kem_460896pcf(); measure_kem_348864(); measure_kem_348864f(); measure_kem_348864pc(); measure_kem_348864pcf(); return 0; } libmceliece-20230612/command/mceliece-test.c0000644000000000000000000055022514441554466017241 0ustar rootroot/* WARNING: auto-generated (by autogen-test); do not edit */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "crypto_uint8.h" #include "crypto_uint32.h" #include "crypto_uint64.h" #include /* -lmceliece */ #include static const char *targeto = 0; static const char *targetp = 0; static const char *targeti = 0; static int ok = 1; #define fail ((ok = 0),printf) /* ----- rng and hash, from supercop/try-anything.c */ typedef crypto_uint8 u8; typedef crypto_uint32 u32; typedef crypto_uint64 u64; #define FOR(i,n) for (i = 0;i < n;++i) static u32 L32(u32 x,int c) { return (x << c) | ((x&0xffffffff) >> (32 - c)); } static u32 ld32(const u8 *x) { u32 u = x[3]; u = (u<<8)|x[2]; u = (u<<8)|x[1]; return (u<<8)|x[0]; } static void st32(u8 *x,u32 u) { int i; FOR(i,4) { x[i] = u; u >>= 8; } } static const u8 sigma[17] = "expand 32-byte k"; static void core_salsa(u8 *out,const u8 *in,const u8 *k) { u32 w[16],x[16],y[16],t[4]; int i,j,m; FOR(i,4) { x[5*i] = ld32(sigma+4*i); x[1+i] = ld32(k+4*i); x[6+i] = ld32(in+4*i); x[11+i] = ld32(k+16+4*i); } FOR(i,16) y[i] = x[i]; FOR(i,20) { FOR(j,4) { FOR(m,4) t[m] = x[(5*j+4*m)%16]; t[1] ^= L32(t[0]+t[3], 7); t[2] ^= L32(t[1]+t[0], 9); t[3] ^= L32(t[2]+t[1],13); t[0] ^= L32(t[3]+t[2],18); FOR(m,4) w[4*j+(j+m)%4] = t[m]; } FOR(m,16) x[m] = w[m]; } FOR(i,16) st32(out + 4 * i,x[i] + y[i]); } static void salsa20(u8 *c,u64 b,const u8 *n,const u8 *k) { u8 z[16],x[64]; u32 u,i; if (!b) return; FOR(i,16) z[i] = 0; FOR(i,8) z[i] = n[i]; while (b >= 64) { core_salsa(x,z,k); FOR(i,64) c[i] = x[i]; u = 1; for (i = 8;i < 16;++i) { u += (u32) z[i]; z[i] = u; u >>= 8; } b -= 64; c += 64; } if (b) { core_salsa(x,z,k); FOR(i,b) c[i] = x[i]; } } static void increment(u8 *n) { if (!++n[0]) if (!++n[1]) if (!++n[2]) if (!++n[3]) if (!++n[4]) if (!++n[5]) if (!++n[6]) if (!++n[7]) ; } static unsigned char testvector_n[8]; static void testvector_clear(void) { memset(testvector_n,0,sizeof testvector_n); } static void testvector(unsigned char *x,unsigned long long xlen) { const static unsigned char testvector_k[33] = "generate inputs for test vectors"; salsa20(x,xlen,testvector_n,testvector_k); increment(testvector_n); } static unsigned long long myrandom(void) { unsigned char x[8]; unsigned long long result; testvector(x,8); result = x[7]; result = (result<<8)|x[6]; result = (result<<8)|x[5]; result = (result<<8)|x[4]; result = (result<<8)|x[3]; result = (result<<8)|x[2]; result = (result<<8)|x[1]; result = (result<<8)|x[0]; return result; } static unsigned char canary_n[8]; static void canary(unsigned char *x,unsigned long long xlen) { const static unsigned char canary_k[33] = "generate pad to catch overwrites"; salsa20(x,xlen,canary_n,canary_k); increment(canary_n); } static void double_canary(unsigned char *x2,unsigned char *x,unsigned long long xlen) { canary(x - 16,16); canary(x + xlen,16); memcpy(x2 - 16,x - 16,16); memcpy(x2 + xlen,x + xlen,16); } static void input_prepare(unsigned char *x2,unsigned char *x,unsigned long long xlen) { testvector(x,xlen); canary(x - 16,16); canary(x + xlen,16); memcpy(x2 - 16,x - 16,xlen + 32); } static void input_compare(const unsigned char *x2,const unsigned char *x,unsigned long long xlen,const char *fun) { if (memcmp(x2 - 16,x - 16,xlen + 32)) { fail("failure: %s overwrites input\n",fun); } } static void output_prepare(unsigned char *x2,unsigned char *x,unsigned long long xlen) { canary(x - 16,xlen + 32); memcpy(x2 - 16,x - 16,xlen + 32); } static void output_compare(const unsigned char *x2,const unsigned char *x,unsigned long long xlen,const char *fun) { if (memcmp(x2 - 16,x - 16,16)) { fail("failure: %s writes before output\n",fun); } if (memcmp(x2 + xlen,x + xlen,16)) { fail("failure: %s writes after output\n",fun); } } /* ----- knownrandombytes */ static const int knownrandombytes_is_only_for_testing_not_for_cryptographic_use = 1; #define knownrandombytes randombytes #define QUARTERROUND(a,b,c,d) \ a += b; d = L32(d^a,16); \ c += d; b = L32(b^c,12); \ a += b; d = L32(d^a, 8); \ c += d; b = L32(b^c, 7); static void core_chacha(u8 *out,const u8 *in,const u8 *k) { u32 x[16],y[16]; int i,j; FOR(i,4) { x[i] = ld32(sigma+4*i); x[12+i] = ld32(in+4*i); } FOR(i,8) x[4+i] = ld32(k+4*i); FOR(i,16) y[i] = x[i]; FOR(i,10) { FOR(j,4) { QUARTERROUND(x[j],x[j+4],x[j+8],x[j+12]) } FOR(j,4) { QUARTERROUND(x[j],x[((j+1)&3)+4],x[((j+2)&3)+8],x[((j+3)&3)+12]) } } FOR(i,16) st32(out+4*i,x[i]+y[i]); } static void chacha20(u8 *c,u64 b,const u8 *n,const u8 *k) { u8 z[16],x[64]; u32 u,i; if (!b) return; FOR(i,16) z[i] = 0; FOR(i,8) z[i+8] = n[i]; while (b >= 64) { core_chacha(x,z,k); FOR(i,64) c[i] = x[i]; u = 1; FOR(i,8) { u += (u32) z[i]; z[i] = u; u >>= 8; } b -= 64; c += 64; } if (b) { core_chacha(x,z,k); FOR(i,b) c[i] = x[i]; } } #define crypto_rng_OUTPUTBYTES 736 static int crypto_rng( unsigned char *r, /* random output */ unsigned char *n, /* new key */ const unsigned char *g /* old key */ ) { static const unsigned char nonce[8] = {0}; unsigned char x[32+crypto_rng_OUTPUTBYTES]; chacha20(x,sizeof x,nonce,g); memcpy(n,x,32); memcpy(r,x+32,crypto_rng_OUTPUTBYTES); return 0; } static unsigned char knownrandombytes_g[32]; static unsigned char knownrandombytes_r[crypto_rng_OUTPUTBYTES]; static unsigned long long knownrandombytes_pos = crypto_rng_OUTPUTBYTES; static void knownrandombytes_clear(void) { memset(knownrandombytes_g,0,sizeof knownrandombytes_g); memset(knownrandombytes_r,0,sizeof knownrandombytes_r); knownrandombytes_pos = crypto_rng_OUTPUTBYTES; } void knownrandombytes(void *xvoid,long long xlen) { unsigned char *x = xvoid; assert(knownrandombytes_is_only_for_testing_not_for_cryptographic_use); while (xlen > 0) { if (knownrandombytes_pos == crypto_rng_OUTPUTBYTES) { crypto_rng(knownrandombytes_r,knownrandombytes_g,knownrandombytes_g); knownrandombytes_pos = 0; } *x++ = knownrandombytes_r[knownrandombytes_pos]; xlen -= 1; knownrandombytes_r[knownrandombytes_pos++] = 0; } } /* ----- checksums */ static unsigned char checksum_state[64]; static char checksum_hex[65]; static void checksum_expected(const char *expected) { long long i; for (i = 0;i < 32;++i) { checksum_hex[2 * i] = "0123456789abcdef"[15 & (checksum_state[i] >> 4)]; checksum_hex[2 * i + 1] = "0123456789abcdef"[15 & checksum_state[i]]; } checksum_hex[2 * i] = 0; if (strcmp(checksum_hex,expected)) fail("failure: checksum mismatch: %s expected %s\n",checksum_hex,expected); } static void checksum_clear(void) { memset(checksum_state,0,sizeof checksum_state); knownrandombytes_clear(); testvector_clear(); /* not necessary to clear canary */ } static void checksum(const unsigned char *x,unsigned long long xlen) { u8 block[16]; int i; while (xlen >= 16) { core_salsa(checksum_state,x,checksum_state); x += 16; xlen -= 16; } FOR(i,16) block[i] = 0; FOR(i,xlen) block[i] = x[i]; block[xlen] = 1; checksum_state[0] ^= 1; core_salsa(checksum_state,block,checksum_state); } #include "limits.inc" static void *callocplus(long long len) { long long i; unsigned char *x = calloc(1,len + 256); if (!x) abort(); for (i = 0;i < len + 256;++i) x[i] = random(); return x; } static void *aligned(void *x,long long len) { long long i; unsigned char *y = x; y += 64; y += 63 & (-(unsigned long) y); for (i = 0;i < len;++i) y[i] = 0; return y; } /* ----- catching SIGILL, SIGBUS, SIGSEGV, etc. */ static void forked(void (*test)(long long),long long impl) { fflush(stdout); pid_t child = fork(); int childstatus = -1; if (child == -1) { fprintf(stderr,"fatal: fork failed: %s",strerror(errno)); exit(111); } if (child == 0) { ok = 1; limits(); test(impl); if (!ok) exit(100); exit(0); } if (waitpid(child,&childstatus,0) != child) { fprintf(stderr,"fatal: wait failed: %s",strerror(errno)); exit(111); } if (childstatus) fail("failure: process failed, status %d\n",childstatus); fflush(stdout); } /* ----- endianness */ /* on big-endian machines, flip into little-endian */ /* other types of endianness are not supported */ static void endianness(unsigned char *e,unsigned long long words,unsigned long long bytesperword) { long long i = 1; if (1 == *(unsigned char *) &i) return; while (words > 0) { for (i = 0;2 * i < bytesperword;++i) { long long j = bytesperword - 1 - i; unsigned char ei = e[i]; e[i] = e[j]; e[j] = ei; } e += bytesperword; words -= 1; } } /* ----- xof, derived from supercop/crypto_xof/try.c */ static const char *xof_shake256_checksums[] = { "a3c4908bf4412d650a1f0a69587778b72aeea66db5a9991a4f0cf2d782ca65b9", "27d81315afb30a84e66c5cc70700b5087142e5748a3b50392f28758148c40644", } ; static void (*crypto_xof)(unsigned char *,long long,const unsigned char *,long long); static void *storage_xof_shake256_h; static unsigned char *test_xof_shake256_h; static void *storage_xof_shake256_m; static unsigned char *test_xof_shake256_m; static void *storage_xof_shake256_h2; static unsigned char *test_xof_shake256_h2; static void *storage_xof_shake256_m2; static unsigned char *test_xof_shake256_m2; static void test_xof_shake256_impl(long long impl) { unsigned char *h = test_xof_shake256_h; unsigned char *m = test_xof_shake256_m; unsigned char *h2 = test_xof_shake256_h2; unsigned char *m2 = test_xof_shake256_m2; long long hlen; long long mlen; if (targeti && strcmp(targeti,mceliece_dispatch_xof_shake256_implementation(impl))) return; if (impl >= 0) { crypto_xof = mceliece_dispatch_xof_shake256(impl); printf("xof_shake256 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_xof_shake256_implementation(impl),mceliece_dispatch_xof_shake256_compiler(impl)); } else { crypto_xof = mceliece_xof_shake256; printf("xof_shake256 selected implementation %s compiler %s\n",mceliece_xof_shake256_implementation(),mceliece_xof_shake256_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 512 : 64; long long maxtest = checksumbig ? 4096 : 128; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { mlen = myrandom() % (maxtest + 1); hlen = myrandom() % (maxtest + 1); output_prepare(h2,h,hlen); input_prepare(m2,m,mlen); crypto_xof(h,hlen,m,mlen); checksum(h,hlen); output_compare(h2,h,hlen,"crypto_xof"); input_compare(m2,m,mlen,"crypto_xof"); double_canary(h2,h,hlen); double_canary(m2,m,mlen); crypto_xof(h2,hlen,m2,mlen); if (memcmp(h2,h,hlen) != 0) fail("failure: crypto_xof is nondeterministic\n"); double_canary(h2,h,hlen); double_canary(m2,m,mlen); crypto_xof(m2,hlen,m2,mlen); if (memcmp(m2,h,hlen) != 0) fail("failure: crypto_xof does not handle m=h overlap\n"); memcpy(m2,m,mlen); } checksum_expected(xof_shake256_checksums[checksumbig]); } } static void test_xof_shake256(void) { if (targeto && strcmp(targeto,"xof")) return; if (targetp && strcmp(targetp,"shake256")) return; storage_xof_shake256_h = callocplus(4096); test_xof_shake256_h = aligned(storage_xof_shake256_h,4096); storage_xof_shake256_m = callocplus(4096); test_xof_shake256_m = aligned(storage_xof_shake256_m,4096); storage_xof_shake256_h2 = callocplus(4096); test_xof_shake256_h2 = aligned(storage_xof_shake256_h2,4096); storage_xof_shake256_m2 = callocplus(4096); test_xof_shake256_m2 = aligned(storage_xof_shake256_m2,4096); for (long long offset = 0;offset < 2;++offset) { printf("xof_shake256 offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_xof_shake256();++impl) forked(test_xof_shake256_impl,impl); ++test_xof_shake256_h; ++test_xof_shake256_m; ++test_xof_shake256_h2; ++test_xof_shake256_m2; } free(storage_xof_shake256_m2); free(storage_xof_shake256_h2); free(storage_xof_shake256_m); free(storage_xof_shake256_h); } /* ----- sort, derived from supercop/crypto_sort/try.c */ static const char *sort_int32_checksums[] = { "3458da92fdba9924c019db57dd7079f7613df0e243f3b312d10d94781af8c29a", "7265f7d8ed54b4a3bd12db9648e246615363373e7044c8d1b7c789ebfc177629", } ; static void (*crypto_sort)(void *,long long); #define crypto_sort_BYTES mceliece_sort_int32_BYTES static void *storage_sort_int32_x; static unsigned char *test_sort_int32_x; static void *storage_sort_int32_x2; static unsigned char *test_sort_int32_x2; static void test_sort_int32_impl(long long impl) { unsigned char *x = test_sort_int32_x; unsigned char *x2 = test_sort_int32_x2; long long xlen; long long xwords; if (targeti && strcmp(targeti,mceliece_dispatch_sort_int32_implementation(impl))) return; if (impl >= 0) { crypto_sort = mceliece_dispatch_sort_int32(impl); printf("sort_int32 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_sort_int32_implementation(impl),mceliece_dispatch_sort_int32_compiler(impl)); } else { crypto_sort = mceliece_sort_int32; printf("sort_int32 selected implementation %s compiler %s\n",mceliece_sort_int32_implementation(),mceliece_sort_int32_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 4096 : 1024; long long maxtest = checksumbig ? 4096 : 128; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { xwords = myrandom() % (maxtest + 1); xlen = mceliece_sort_int32_BYTES*xwords; input_prepare(x2,x,xlen); endianness(x,xwords,mceliece_sort_int32_BYTES); crypto_sort(x,xwords); endianness(x,xwords,mceliece_sort_int32_BYTES); checksum(x,xlen); output_compare(x2,x,xlen,"crypto_sort"); double_canary(x2,x,xlen); endianness(x2,xwords,mceliece_sort_int32_BYTES); crypto_sort(x2,xwords); endianness(x2,xwords,mceliece_sort_int32_BYTES); if (memcmp(x2,x,xlen) != 0) fail("failure: crypto_sort is nondeterministic\n"); } checksum_expected(sort_int32_checksums[checksumbig]); } } static void test_sort_int32(void) { if (targeto && strcmp(targeto,"sort")) return; if (targetp && strcmp(targetp,"int32")) return; storage_sort_int32_x = callocplus(mceliece_sort_int32_BYTES*4096); test_sort_int32_x = aligned(storage_sort_int32_x,mceliece_sort_int32_BYTES*4096); storage_sort_int32_x2 = callocplus(mceliece_sort_int32_BYTES*4096); test_sort_int32_x2 = aligned(storage_sort_int32_x2,mceliece_sort_int32_BYTES*4096); for (long long offset = 0;offset < 2;++offset) { printf("sort_int32 offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_sort_int32();++impl) forked(test_sort_int32_impl,impl); ++test_sort_int32_x; ++test_sort_int32_x2; } free(storage_sort_int32_x2); free(storage_sort_int32_x); } #undef crypto_sort_BYTES /* ----- kem, derived from supercop/crypto_kem/try.c */ static const char *kem_6960119_checksums[] = { "008c0538526a1c037e64f0543628b312a71e879c1f882f65493fd0d3a225d5d8", "15c6727d4f4867487a54bbb208c06c1142a56a7937d7b598c05f63801cbdd277", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6960119_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6960119_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6960119_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6960119_BYTES static void *storage_kem_6960119_p; static unsigned char *test_kem_6960119_p; static void *storage_kem_6960119_s; static unsigned char *test_kem_6960119_s; static void *storage_kem_6960119_k; static unsigned char *test_kem_6960119_k; static void *storage_kem_6960119_c; static unsigned char *test_kem_6960119_c; static void *storage_kem_6960119_t; static unsigned char *test_kem_6960119_t; static void *storage_kem_6960119_p2; static unsigned char *test_kem_6960119_p2; static void *storage_kem_6960119_s2; static unsigned char *test_kem_6960119_s2; static void *storage_kem_6960119_k2; static unsigned char *test_kem_6960119_k2; static void *storage_kem_6960119_c2; static unsigned char *test_kem_6960119_c2; static void *storage_kem_6960119_t2; static unsigned char *test_kem_6960119_t2; static void test_kem_6960119_impl(long long impl) { unsigned char *p = test_kem_6960119_p; unsigned char *s = test_kem_6960119_s; unsigned char *k = test_kem_6960119_k; unsigned char *c = test_kem_6960119_c; unsigned char *t = test_kem_6960119_t; unsigned char *p2 = test_kem_6960119_p2; unsigned char *s2 = test_kem_6960119_s2; unsigned char *k2 = test_kem_6960119_k2; unsigned char *c2 = test_kem_6960119_c2; unsigned char *t2 = test_kem_6960119_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119_dec(impl); printf("kem_6960119 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119_implementation(impl),mceliece_dispatch_kem_6960119_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119_keypair; crypto_kem_enc = mceliece_kem_6960119_enc; crypto_kem_dec = mceliece_kem_6960119_dec; printf("kem_6960119 selected implementation %s compiler %s\n",mceliece_kem_6960119_implementation(),mceliece_kem_6960119_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6960119_checksums[checksumbig]); } } static void test_kem_6960119(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119")) return; storage_kem_6960119_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119_p = aligned(storage_kem_6960119_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119_s = aligned(storage_kem_6960119_s,crypto_kem_SECRETKEYBYTES); storage_kem_6960119_k = callocplus(crypto_kem_BYTES); test_kem_6960119_k = aligned(storage_kem_6960119_k,crypto_kem_BYTES); storage_kem_6960119_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119_c = aligned(storage_kem_6960119_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119_t = callocplus(crypto_kem_BYTES); test_kem_6960119_t = aligned(storage_kem_6960119_t,crypto_kem_BYTES); storage_kem_6960119_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119_p2 = aligned(storage_kem_6960119_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119_s2 = aligned(storage_kem_6960119_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6960119_k2 = callocplus(crypto_kem_BYTES); test_kem_6960119_k2 = aligned(storage_kem_6960119_k2,crypto_kem_BYTES); storage_kem_6960119_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119_c2 = aligned(storage_kem_6960119_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119_t2 = callocplus(crypto_kem_BYTES); test_kem_6960119_t2 = aligned(storage_kem_6960119_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6960119 offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119();++impl) forked(test_kem_6960119_impl,impl); ++test_kem_6960119_p; ++test_kem_6960119_s; ++test_kem_6960119_k; ++test_kem_6960119_c; ++test_kem_6960119_t; ++test_kem_6960119_p2; ++test_kem_6960119_s2; ++test_kem_6960119_k2; ++test_kem_6960119_c2; ++test_kem_6960119_t2; } free(storage_kem_6960119_t2); free(storage_kem_6960119_c2); free(storage_kem_6960119_k2); free(storage_kem_6960119_s2); free(storage_kem_6960119_p2); free(storage_kem_6960119_t); free(storage_kem_6960119_c); free(storage_kem_6960119_k); free(storage_kem_6960119_s); free(storage_kem_6960119_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_6960119f_checksums[] = { "8d0f85c0ffa074aff7cf1c5d2f8a048174de4ee62a74556e04e8da326e8b640d", "d62841358b16796439c261003bae87733ef9889374061bce0a261f80b072861f", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6960119f_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6960119f_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6960119f_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6960119f_BYTES static void *storage_kem_6960119f_p; static unsigned char *test_kem_6960119f_p; static void *storage_kem_6960119f_s; static unsigned char *test_kem_6960119f_s; static void *storage_kem_6960119f_k; static unsigned char *test_kem_6960119f_k; static void *storage_kem_6960119f_c; static unsigned char *test_kem_6960119f_c; static void *storage_kem_6960119f_t; static unsigned char *test_kem_6960119f_t; static void *storage_kem_6960119f_p2; static unsigned char *test_kem_6960119f_p2; static void *storage_kem_6960119f_s2; static unsigned char *test_kem_6960119f_s2; static void *storage_kem_6960119f_k2; static unsigned char *test_kem_6960119f_k2; static void *storage_kem_6960119f_c2; static unsigned char *test_kem_6960119f_c2; static void *storage_kem_6960119f_t2; static unsigned char *test_kem_6960119f_t2; static void test_kem_6960119f_impl(long long impl) { unsigned char *p = test_kem_6960119f_p; unsigned char *s = test_kem_6960119f_s; unsigned char *k = test_kem_6960119f_k; unsigned char *c = test_kem_6960119f_c; unsigned char *t = test_kem_6960119f_t; unsigned char *p2 = test_kem_6960119f_p2; unsigned char *s2 = test_kem_6960119f_s2; unsigned char *k2 = test_kem_6960119f_k2; unsigned char *c2 = test_kem_6960119f_c2; unsigned char *t2 = test_kem_6960119f_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119f_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119f_dec(impl); printf("kem_6960119f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119f_implementation(impl),mceliece_dispatch_kem_6960119f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119f_keypair; crypto_kem_enc = mceliece_kem_6960119f_enc; crypto_kem_dec = mceliece_kem_6960119f_dec; printf("kem_6960119f selected implementation %s compiler %s\n",mceliece_kem_6960119f_implementation(),mceliece_kem_6960119f_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6960119f_checksums[checksumbig]); } } static void test_kem_6960119f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119f")) return; storage_kem_6960119f_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119f_p = aligned(storage_kem_6960119f_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119f_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119f_s = aligned(storage_kem_6960119f_s,crypto_kem_SECRETKEYBYTES); storage_kem_6960119f_k = callocplus(crypto_kem_BYTES); test_kem_6960119f_k = aligned(storage_kem_6960119f_k,crypto_kem_BYTES); storage_kem_6960119f_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119f_c = aligned(storage_kem_6960119f_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119f_t = callocplus(crypto_kem_BYTES); test_kem_6960119f_t = aligned(storage_kem_6960119f_t,crypto_kem_BYTES); storage_kem_6960119f_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119f_p2 = aligned(storage_kem_6960119f_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119f_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119f_s2 = aligned(storage_kem_6960119f_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6960119f_k2 = callocplus(crypto_kem_BYTES); test_kem_6960119f_k2 = aligned(storage_kem_6960119f_k2,crypto_kem_BYTES); storage_kem_6960119f_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119f_c2 = aligned(storage_kem_6960119f_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119f_t2 = callocplus(crypto_kem_BYTES); test_kem_6960119f_t2 = aligned(storage_kem_6960119f_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6960119f offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119f();++impl) forked(test_kem_6960119f_impl,impl); ++test_kem_6960119f_p; ++test_kem_6960119f_s; ++test_kem_6960119f_k; ++test_kem_6960119f_c; ++test_kem_6960119f_t; ++test_kem_6960119f_p2; ++test_kem_6960119f_s2; ++test_kem_6960119f_k2; ++test_kem_6960119f_c2; ++test_kem_6960119f_t2; } free(storage_kem_6960119f_t2); free(storage_kem_6960119f_c2); free(storage_kem_6960119f_k2); free(storage_kem_6960119f_s2); free(storage_kem_6960119f_p2); free(storage_kem_6960119f_t); free(storage_kem_6960119f_c); free(storage_kem_6960119f_k); free(storage_kem_6960119f_s); free(storage_kem_6960119f_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_6960119pc_checksums[] = { "f164d7a16ea6175870f34056b211d4d45a2bc95085759e2f688721f3fbf326c8", "7f2438a79d20ae3b056f2d13bca43ea7c1ba2a2e0535cc35f7016188910a4720", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6960119pc_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6960119pc_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6960119pc_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6960119pc_BYTES static void *storage_kem_6960119pc_p; static unsigned char *test_kem_6960119pc_p; static void *storage_kem_6960119pc_s; static unsigned char *test_kem_6960119pc_s; static void *storage_kem_6960119pc_k; static unsigned char *test_kem_6960119pc_k; static void *storage_kem_6960119pc_c; static unsigned char *test_kem_6960119pc_c; static void *storage_kem_6960119pc_t; static unsigned char *test_kem_6960119pc_t; static void *storage_kem_6960119pc_p2; static unsigned char *test_kem_6960119pc_p2; static void *storage_kem_6960119pc_s2; static unsigned char *test_kem_6960119pc_s2; static void *storage_kem_6960119pc_k2; static unsigned char *test_kem_6960119pc_k2; static void *storage_kem_6960119pc_c2; static unsigned char *test_kem_6960119pc_c2; static void *storage_kem_6960119pc_t2; static unsigned char *test_kem_6960119pc_t2; static void test_kem_6960119pc_impl(long long impl) { unsigned char *p = test_kem_6960119pc_p; unsigned char *s = test_kem_6960119pc_s; unsigned char *k = test_kem_6960119pc_k; unsigned char *c = test_kem_6960119pc_c; unsigned char *t = test_kem_6960119pc_t; unsigned char *p2 = test_kem_6960119pc_p2; unsigned char *s2 = test_kem_6960119pc_s2; unsigned char *k2 = test_kem_6960119pc_k2; unsigned char *c2 = test_kem_6960119pc_c2; unsigned char *t2 = test_kem_6960119pc_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119pc_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119pc_dec(impl); printf("kem_6960119pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119pc_implementation(impl),mceliece_dispatch_kem_6960119pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119pc_keypair; crypto_kem_enc = mceliece_kem_6960119pc_enc; crypto_kem_dec = mceliece_kem_6960119pc_dec; printf("kem_6960119pc selected implementation %s compiler %s\n",mceliece_kem_6960119pc_implementation(),mceliece_kem_6960119pc_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6960119pc_checksums[checksumbig]); } } static void test_kem_6960119pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119pc")) return; storage_kem_6960119pc_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119pc_p = aligned(storage_kem_6960119pc_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119pc_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119pc_s = aligned(storage_kem_6960119pc_s,crypto_kem_SECRETKEYBYTES); storage_kem_6960119pc_k = callocplus(crypto_kem_BYTES); test_kem_6960119pc_k = aligned(storage_kem_6960119pc_k,crypto_kem_BYTES); storage_kem_6960119pc_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119pc_c = aligned(storage_kem_6960119pc_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119pc_t = callocplus(crypto_kem_BYTES); test_kem_6960119pc_t = aligned(storage_kem_6960119pc_t,crypto_kem_BYTES); storage_kem_6960119pc_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119pc_p2 = aligned(storage_kem_6960119pc_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119pc_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119pc_s2 = aligned(storage_kem_6960119pc_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6960119pc_k2 = callocplus(crypto_kem_BYTES); test_kem_6960119pc_k2 = aligned(storage_kem_6960119pc_k2,crypto_kem_BYTES); storage_kem_6960119pc_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119pc_c2 = aligned(storage_kem_6960119pc_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119pc_t2 = callocplus(crypto_kem_BYTES); test_kem_6960119pc_t2 = aligned(storage_kem_6960119pc_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6960119pc offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119pc();++impl) forked(test_kem_6960119pc_impl,impl); ++test_kem_6960119pc_p; ++test_kem_6960119pc_s; ++test_kem_6960119pc_k; ++test_kem_6960119pc_c; ++test_kem_6960119pc_t; ++test_kem_6960119pc_p2; ++test_kem_6960119pc_s2; ++test_kem_6960119pc_k2; ++test_kem_6960119pc_c2; ++test_kem_6960119pc_t2; } free(storage_kem_6960119pc_t2); free(storage_kem_6960119pc_c2); free(storage_kem_6960119pc_k2); free(storage_kem_6960119pc_s2); free(storage_kem_6960119pc_p2); free(storage_kem_6960119pc_t); free(storage_kem_6960119pc_c); free(storage_kem_6960119pc_k); free(storage_kem_6960119pc_s); free(storage_kem_6960119pc_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_6960119pcf_checksums[] = { "873616887e3e83679d5a708b3fbd8eb2301d18ea21f0f7c238db87178596267a", "d709f666d84fe4450ec59759ef20982df8d614afe788db2b7d0f91b0c0e02254", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6960119pcf_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6960119pcf_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6960119pcf_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6960119pcf_BYTES static void *storage_kem_6960119pcf_p; static unsigned char *test_kem_6960119pcf_p; static void *storage_kem_6960119pcf_s; static unsigned char *test_kem_6960119pcf_s; static void *storage_kem_6960119pcf_k; static unsigned char *test_kem_6960119pcf_k; static void *storage_kem_6960119pcf_c; static unsigned char *test_kem_6960119pcf_c; static void *storage_kem_6960119pcf_t; static unsigned char *test_kem_6960119pcf_t; static void *storage_kem_6960119pcf_p2; static unsigned char *test_kem_6960119pcf_p2; static void *storage_kem_6960119pcf_s2; static unsigned char *test_kem_6960119pcf_s2; static void *storage_kem_6960119pcf_k2; static unsigned char *test_kem_6960119pcf_k2; static void *storage_kem_6960119pcf_c2; static unsigned char *test_kem_6960119pcf_c2; static void *storage_kem_6960119pcf_t2; static unsigned char *test_kem_6960119pcf_t2; static void test_kem_6960119pcf_impl(long long impl) { unsigned char *p = test_kem_6960119pcf_p; unsigned char *s = test_kem_6960119pcf_s; unsigned char *k = test_kem_6960119pcf_k; unsigned char *c = test_kem_6960119pcf_c; unsigned char *t = test_kem_6960119pcf_t; unsigned char *p2 = test_kem_6960119pcf_p2; unsigned char *s2 = test_kem_6960119pcf_s2; unsigned char *k2 = test_kem_6960119pcf_k2; unsigned char *c2 = test_kem_6960119pcf_c2; unsigned char *t2 = test_kem_6960119pcf_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6960119pcf_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6960119pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6960119pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6960119pcf_dec(impl); printf("kem_6960119pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6960119pcf_implementation(impl),mceliece_dispatch_kem_6960119pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6960119pcf_keypair; crypto_kem_enc = mceliece_kem_6960119pcf_enc; crypto_kem_dec = mceliece_kem_6960119pcf_dec; printf("kem_6960119pcf selected implementation %s compiler %s\n",mceliece_kem_6960119pcf_implementation(),mceliece_kem_6960119pcf_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6960119pcf_checksums[checksumbig]); } } static void test_kem_6960119pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6960119pcf")) return; storage_kem_6960119pcf_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119pcf_p = aligned(storage_kem_6960119pcf_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119pcf_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119pcf_s = aligned(storage_kem_6960119pcf_s,crypto_kem_SECRETKEYBYTES); storage_kem_6960119pcf_k = callocplus(crypto_kem_BYTES); test_kem_6960119pcf_k = aligned(storage_kem_6960119pcf_k,crypto_kem_BYTES); storage_kem_6960119pcf_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119pcf_c = aligned(storage_kem_6960119pcf_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119pcf_t = callocplus(crypto_kem_BYTES); test_kem_6960119pcf_t = aligned(storage_kem_6960119pcf_t,crypto_kem_BYTES); storage_kem_6960119pcf_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6960119pcf_p2 = aligned(storage_kem_6960119pcf_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6960119pcf_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6960119pcf_s2 = aligned(storage_kem_6960119pcf_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6960119pcf_k2 = callocplus(crypto_kem_BYTES); test_kem_6960119pcf_k2 = aligned(storage_kem_6960119pcf_k2,crypto_kem_BYTES); storage_kem_6960119pcf_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6960119pcf_c2 = aligned(storage_kem_6960119pcf_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6960119pcf_t2 = callocplus(crypto_kem_BYTES); test_kem_6960119pcf_t2 = aligned(storage_kem_6960119pcf_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6960119pcf offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6960119pcf();++impl) forked(test_kem_6960119pcf_impl,impl); ++test_kem_6960119pcf_p; ++test_kem_6960119pcf_s; ++test_kem_6960119pcf_k; ++test_kem_6960119pcf_c; ++test_kem_6960119pcf_t; ++test_kem_6960119pcf_p2; ++test_kem_6960119pcf_s2; ++test_kem_6960119pcf_k2; ++test_kem_6960119pcf_c2; ++test_kem_6960119pcf_t2; } free(storage_kem_6960119pcf_t2); free(storage_kem_6960119pcf_c2); free(storage_kem_6960119pcf_k2); free(storage_kem_6960119pcf_s2); free(storage_kem_6960119pcf_p2); free(storage_kem_6960119pcf_t); free(storage_kem_6960119pcf_c); free(storage_kem_6960119pcf_k); free(storage_kem_6960119pcf_s); free(storage_kem_6960119pcf_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_6688128_checksums[] = { "a3446acecf9aff0e757dfafc5402e365eb3ba485dd1f7b052f3ca6eabfdcb6c4", "b2ee78aaa23c0612155239b1d92e9e1af589cb810bdb9d8c44eb85dbfd2e46d4", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6688128_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6688128_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6688128_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6688128_BYTES static void *storage_kem_6688128_p; static unsigned char *test_kem_6688128_p; static void *storage_kem_6688128_s; static unsigned char *test_kem_6688128_s; static void *storage_kem_6688128_k; static unsigned char *test_kem_6688128_k; static void *storage_kem_6688128_c; static unsigned char *test_kem_6688128_c; static void *storage_kem_6688128_t; static unsigned char *test_kem_6688128_t; static void *storage_kem_6688128_p2; static unsigned char *test_kem_6688128_p2; static void *storage_kem_6688128_s2; static unsigned char *test_kem_6688128_s2; static void *storage_kem_6688128_k2; static unsigned char *test_kem_6688128_k2; static void *storage_kem_6688128_c2; static unsigned char *test_kem_6688128_c2; static void *storage_kem_6688128_t2; static unsigned char *test_kem_6688128_t2; static void test_kem_6688128_impl(long long impl) { unsigned char *p = test_kem_6688128_p; unsigned char *s = test_kem_6688128_s; unsigned char *k = test_kem_6688128_k; unsigned char *c = test_kem_6688128_c; unsigned char *t = test_kem_6688128_t; unsigned char *p2 = test_kem_6688128_p2; unsigned char *s2 = test_kem_6688128_s2; unsigned char *k2 = test_kem_6688128_k2; unsigned char *c2 = test_kem_6688128_c2; unsigned char *t2 = test_kem_6688128_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128_dec(impl); printf("kem_6688128 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128_implementation(impl),mceliece_dispatch_kem_6688128_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128_keypair; crypto_kem_enc = mceliece_kem_6688128_enc; crypto_kem_dec = mceliece_kem_6688128_dec; printf("kem_6688128 selected implementation %s compiler %s\n",mceliece_kem_6688128_implementation(),mceliece_kem_6688128_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6688128_checksums[checksumbig]); } } static void test_kem_6688128(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128")) return; storage_kem_6688128_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128_p = aligned(storage_kem_6688128_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128_s = aligned(storage_kem_6688128_s,crypto_kem_SECRETKEYBYTES); storage_kem_6688128_k = callocplus(crypto_kem_BYTES); test_kem_6688128_k = aligned(storage_kem_6688128_k,crypto_kem_BYTES); storage_kem_6688128_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128_c = aligned(storage_kem_6688128_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128_t = callocplus(crypto_kem_BYTES); test_kem_6688128_t = aligned(storage_kem_6688128_t,crypto_kem_BYTES); storage_kem_6688128_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128_p2 = aligned(storage_kem_6688128_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128_s2 = aligned(storage_kem_6688128_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6688128_k2 = callocplus(crypto_kem_BYTES); test_kem_6688128_k2 = aligned(storage_kem_6688128_k2,crypto_kem_BYTES); storage_kem_6688128_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128_c2 = aligned(storage_kem_6688128_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128_t2 = callocplus(crypto_kem_BYTES); test_kem_6688128_t2 = aligned(storage_kem_6688128_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6688128 offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128();++impl) forked(test_kem_6688128_impl,impl); ++test_kem_6688128_p; ++test_kem_6688128_s; ++test_kem_6688128_k; ++test_kem_6688128_c; ++test_kem_6688128_t; ++test_kem_6688128_p2; ++test_kem_6688128_s2; ++test_kem_6688128_k2; ++test_kem_6688128_c2; ++test_kem_6688128_t2; } free(storage_kem_6688128_t2); free(storage_kem_6688128_c2); free(storage_kem_6688128_k2); free(storage_kem_6688128_s2); free(storage_kem_6688128_p2); free(storage_kem_6688128_t); free(storage_kem_6688128_c); free(storage_kem_6688128_k); free(storage_kem_6688128_s); free(storage_kem_6688128_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_6688128f_checksums[] = { "daec95f7a2db91986d2d1ca7312d66314149b066db0f467935ecf027aa1f4403", "a371ae9485120c1ea108b85723470e5b317ca4428fa01a27b3b5f33f5d924d32", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6688128f_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6688128f_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6688128f_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6688128f_BYTES static void *storage_kem_6688128f_p; static unsigned char *test_kem_6688128f_p; static void *storage_kem_6688128f_s; static unsigned char *test_kem_6688128f_s; static void *storage_kem_6688128f_k; static unsigned char *test_kem_6688128f_k; static void *storage_kem_6688128f_c; static unsigned char *test_kem_6688128f_c; static void *storage_kem_6688128f_t; static unsigned char *test_kem_6688128f_t; static void *storage_kem_6688128f_p2; static unsigned char *test_kem_6688128f_p2; static void *storage_kem_6688128f_s2; static unsigned char *test_kem_6688128f_s2; static void *storage_kem_6688128f_k2; static unsigned char *test_kem_6688128f_k2; static void *storage_kem_6688128f_c2; static unsigned char *test_kem_6688128f_c2; static void *storage_kem_6688128f_t2; static unsigned char *test_kem_6688128f_t2; static void test_kem_6688128f_impl(long long impl) { unsigned char *p = test_kem_6688128f_p; unsigned char *s = test_kem_6688128f_s; unsigned char *k = test_kem_6688128f_k; unsigned char *c = test_kem_6688128f_c; unsigned char *t = test_kem_6688128f_t; unsigned char *p2 = test_kem_6688128f_p2; unsigned char *s2 = test_kem_6688128f_s2; unsigned char *k2 = test_kem_6688128f_k2; unsigned char *c2 = test_kem_6688128f_c2; unsigned char *t2 = test_kem_6688128f_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128f_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128f_dec(impl); printf("kem_6688128f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128f_implementation(impl),mceliece_dispatch_kem_6688128f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128f_keypair; crypto_kem_enc = mceliece_kem_6688128f_enc; crypto_kem_dec = mceliece_kem_6688128f_dec; printf("kem_6688128f selected implementation %s compiler %s\n",mceliece_kem_6688128f_implementation(),mceliece_kem_6688128f_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6688128f_checksums[checksumbig]); } } static void test_kem_6688128f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128f")) return; storage_kem_6688128f_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128f_p = aligned(storage_kem_6688128f_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128f_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128f_s = aligned(storage_kem_6688128f_s,crypto_kem_SECRETKEYBYTES); storage_kem_6688128f_k = callocplus(crypto_kem_BYTES); test_kem_6688128f_k = aligned(storage_kem_6688128f_k,crypto_kem_BYTES); storage_kem_6688128f_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128f_c = aligned(storage_kem_6688128f_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128f_t = callocplus(crypto_kem_BYTES); test_kem_6688128f_t = aligned(storage_kem_6688128f_t,crypto_kem_BYTES); storage_kem_6688128f_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128f_p2 = aligned(storage_kem_6688128f_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128f_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128f_s2 = aligned(storage_kem_6688128f_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6688128f_k2 = callocplus(crypto_kem_BYTES); test_kem_6688128f_k2 = aligned(storage_kem_6688128f_k2,crypto_kem_BYTES); storage_kem_6688128f_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128f_c2 = aligned(storage_kem_6688128f_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128f_t2 = callocplus(crypto_kem_BYTES); test_kem_6688128f_t2 = aligned(storage_kem_6688128f_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6688128f offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128f();++impl) forked(test_kem_6688128f_impl,impl); ++test_kem_6688128f_p; ++test_kem_6688128f_s; ++test_kem_6688128f_k; ++test_kem_6688128f_c; ++test_kem_6688128f_t; ++test_kem_6688128f_p2; ++test_kem_6688128f_s2; ++test_kem_6688128f_k2; ++test_kem_6688128f_c2; ++test_kem_6688128f_t2; } free(storage_kem_6688128f_t2); free(storage_kem_6688128f_c2); free(storage_kem_6688128f_k2); free(storage_kem_6688128f_s2); free(storage_kem_6688128f_p2); free(storage_kem_6688128f_t); free(storage_kem_6688128f_c); free(storage_kem_6688128f_k); free(storage_kem_6688128f_s); free(storage_kem_6688128f_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_6688128pc_checksums[] = { "f6d44759e9e52330923b5dc2957cd080c10b31990a96e0540c52ba42017fa849", "53e96db3d38fe59717c537c269eddb0474e0548e964d2fbfbc1082ef03e68857", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6688128pc_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6688128pc_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6688128pc_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6688128pc_BYTES static void *storage_kem_6688128pc_p; static unsigned char *test_kem_6688128pc_p; static void *storage_kem_6688128pc_s; static unsigned char *test_kem_6688128pc_s; static void *storage_kem_6688128pc_k; static unsigned char *test_kem_6688128pc_k; static void *storage_kem_6688128pc_c; static unsigned char *test_kem_6688128pc_c; static void *storage_kem_6688128pc_t; static unsigned char *test_kem_6688128pc_t; static void *storage_kem_6688128pc_p2; static unsigned char *test_kem_6688128pc_p2; static void *storage_kem_6688128pc_s2; static unsigned char *test_kem_6688128pc_s2; static void *storage_kem_6688128pc_k2; static unsigned char *test_kem_6688128pc_k2; static void *storage_kem_6688128pc_c2; static unsigned char *test_kem_6688128pc_c2; static void *storage_kem_6688128pc_t2; static unsigned char *test_kem_6688128pc_t2; static void test_kem_6688128pc_impl(long long impl) { unsigned char *p = test_kem_6688128pc_p; unsigned char *s = test_kem_6688128pc_s; unsigned char *k = test_kem_6688128pc_k; unsigned char *c = test_kem_6688128pc_c; unsigned char *t = test_kem_6688128pc_t; unsigned char *p2 = test_kem_6688128pc_p2; unsigned char *s2 = test_kem_6688128pc_s2; unsigned char *k2 = test_kem_6688128pc_k2; unsigned char *c2 = test_kem_6688128pc_c2; unsigned char *t2 = test_kem_6688128pc_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128pc_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128pc_dec(impl); printf("kem_6688128pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128pc_implementation(impl),mceliece_dispatch_kem_6688128pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128pc_keypair; crypto_kem_enc = mceliece_kem_6688128pc_enc; crypto_kem_dec = mceliece_kem_6688128pc_dec; printf("kem_6688128pc selected implementation %s compiler %s\n",mceliece_kem_6688128pc_implementation(),mceliece_kem_6688128pc_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6688128pc_checksums[checksumbig]); } } static void test_kem_6688128pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128pc")) return; storage_kem_6688128pc_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128pc_p = aligned(storage_kem_6688128pc_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128pc_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128pc_s = aligned(storage_kem_6688128pc_s,crypto_kem_SECRETKEYBYTES); storage_kem_6688128pc_k = callocplus(crypto_kem_BYTES); test_kem_6688128pc_k = aligned(storage_kem_6688128pc_k,crypto_kem_BYTES); storage_kem_6688128pc_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128pc_c = aligned(storage_kem_6688128pc_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128pc_t = callocplus(crypto_kem_BYTES); test_kem_6688128pc_t = aligned(storage_kem_6688128pc_t,crypto_kem_BYTES); storage_kem_6688128pc_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128pc_p2 = aligned(storage_kem_6688128pc_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128pc_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128pc_s2 = aligned(storage_kem_6688128pc_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6688128pc_k2 = callocplus(crypto_kem_BYTES); test_kem_6688128pc_k2 = aligned(storage_kem_6688128pc_k2,crypto_kem_BYTES); storage_kem_6688128pc_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128pc_c2 = aligned(storage_kem_6688128pc_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128pc_t2 = callocplus(crypto_kem_BYTES); test_kem_6688128pc_t2 = aligned(storage_kem_6688128pc_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6688128pc offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128pc();++impl) forked(test_kem_6688128pc_impl,impl); ++test_kem_6688128pc_p; ++test_kem_6688128pc_s; ++test_kem_6688128pc_k; ++test_kem_6688128pc_c; ++test_kem_6688128pc_t; ++test_kem_6688128pc_p2; ++test_kem_6688128pc_s2; ++test_kem_6688128pc_k2; ++test_kem_6688128pc_c2; ++test_kem_6688128pc_t2; } free(storage_kem_6688128pc_t2); free(storage_kem_6688128pc_c2); free(storage_kem_6688128pc_k2); free(storage_kem_6688128pc_s2); free(storage_kem_6688128pc_p2); free(storage_kem_6688128pc_t); free(storage_kem_6688128pc_c); free(storage_kem_6688128pc_k); free(storage_kem_6688128pc_s); free(storage_kem_6688128pc_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_6688128pcf_checksums[] = { "80e0655938457c4dcd6aa6323d60f2495efda8a2d4a13b1958e8ca8fd2e848b6", "a4451d736f136a43032cd4d1047b4b7494ee6d0c91d75deff011e596bdb1b3ec", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_6688128pcf_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_6688128pcf_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_6688128pcf_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_6688128pcf_BYTES static void *storage_kem_6688128pcf_p; static unsigned char *test_kem_6688128pcf_p; static void *storage_kem_6688128pcf_s; static unsigned char *test_kem_6688128pcf_s; static void *storage_kem_6688128pcf_k; static unsigned char *test_kem_6688128pcf_k; static void *storage_kem_6688128pcf_c; static unsigned char *test_kem_6688128pcf_c; static void *storage_kem_6688128pcf_t; static unsigned char *test_kem_6688128pcf_t; static void *storage_kem_6688128pcf_p2; static unsigned char *test_kem_6688128pcf_p2; static void *storage_kem_6688128pcf_s2; static unsigned char *test_kem_6688128pcf_s2; static void *storage_kem_6688128pcf_k2; static unsigned char *test_kem_6688128pcf_k2; static void *storage_kem_6688128pcf_c2; static unsigned char *test_kem_6688128pcf_c2; static void *storage_kem_6688128pcf_t2; static unsigned char *test_kem_6688128pcf_t2; static void test_kem_6688128pcf_impl(long long impl) { unsigned char *p = test_kem_6688128pcf_p; unsigned char *s = test_kem_6688128pcf_s; unsigned char *k = test_kem_6688128pcf_k; unsigned char *c = test_kem_6688128pcf_c; unsigned char *t = test_kem_6688128pcf_t; unsigned char *p2 = test_kem_6688128pcf_p2; unsigned char *s2 = test_kem_6688128pcf_s2; unsigned char *k2 = test_kem_6688128pcf_k2; unsigned char *c2 = test_kem_6688128pcf_c2; unsigned char *t2 = test_kem_6688128pcf_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_6688128pcf_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_6688128pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_6688128pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_6688128pcf_dec(impl); printf("kem_6688128pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_6688128pcf_implementation(impl),mceliece_dispatch_kem_6688128pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_6688128pcf_keypair; crypto_kem_enc = mceliece_kem_6688128pcf_enc; crypto_kem_dec = mceliece_kem_6688128pcf_dec; printf("kem_6688128pcf selected implementation %s compiler %s\n",mceliece_kem_6688128pcf_implementation(),mceliece_kem_6688128pcf_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_6688128pcf_checksums[checksumbig]); } } static void test_kem_6688128pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"6688128pcf")) return; storage_kem_6688128pcf_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128pcf_p = aligned(storage_kem_6688128pcf_p,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128pcf_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128pcf_s = aligned(storage_kem_6688128pcf_s,crypto_kem_SECRETKEYBYTES); storage_kem_6688128pcf_k = callocplus(crypto_kem_BYTES); test_kem_6688128pcf_k = aligned(storage_kem_6688128pcf_k,crypto_kem_BYTES); storage_kem_6688128pcf_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128pcf_c = aligned(storage_kem_6688128pcf_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128pcf_t = callocplus(crypto_kem_BYTES); test_kem_6688128pcf_t = aligned(storage_kem_6688128pcf_t,crypto_kem_BYTES); storage_kem_6688128pcf_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_6688128pcf_p2 = aligned(storage_kem_6688128pcf_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_6688128pcf_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_6688128pcf_s2 = aligned(storage_kem_6688128pcf_s2,crypto_kem_SECRETKEYBYTES); storage_kem_6688128pcf_k2 = callocplus(crypto_kem_BYTES); test_kem_6688128pcf_k2 = aligned(storage_kem_6688128pcf_k2,crypto_kem_BYTES); storage_kem_6688128pcf_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_6688128pcf_c2 = aligned(storage_kem_6688128pcf_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_6688128pcf_t2 = callocplus(crypto_kem_BYTES); test_kem_6688128pcf_t2 = aligned(storage_kem_6688128pcf_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_6688128pcf offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_6688128pcf();++impl) forked(test_kem_6688128pcf_impl,impl); ++test_kem_6688128pcf_p; ++test_kem_6688128pcf_s; ++test_kem_6688128pcf_k; ++test_kem_6688128pcf_c; ++test_kem_6688128pcf_t; ++test_kem_6688128pcf_p2; ++test_kem_6688128pcf_s2; ++test_kem_6688128pcf_k2; ++test_kem_6688128pcf_c2; ++test_kem_6688128pcf_t2; } free(storage_kem_6688128pcf_t2); free(storage_kem_6688128pcf_c2); free(storage_kem_6688128pcf_k2); free(storage_kem_6688128pcf_s2); free(storage_kem_6688128pcf_p2); free(storage_kem_6688128pcf_t); free(storage_kem_6688128pcf_c); free(storage_kem_6688128pcf_k); free(storage_kem_6688128pcf_s); free(storage_kem_6688128pcf_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_8192128_checksums[] = { "debad73db5027e8239b7e97d04c5a98b7521caba8ea4e58581c90efb50dd4b9e", "5e64e0aeb5ab566a1efbb2b1127dcbf909ee1b395945f066cd5f097a85f2e135", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_8192128_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_8192128_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_8192128_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_8192128_BYTES static void *storage_kem_8192128_p; static unsigned char *test_kem_8192128_p; static void *storage_kem_8192128_s; static unsigned char *test_kem_8192128_s; static void *storage_kem_8192128_k; static unsigned char *test_kem_8192128_k; static void *storage_kem_8192128_c; static unsigned char *test_kem_8192128_c; static void *storage_kem_8192128_t; static unsigned char *test_kem_8192128_t; static void *storage_kem_8192128_p2; static unsigned char *test_kem_8192128_p2; static void *storage_kem_8192128_s2; static unsigned char *test_kem_8192128_s2; static void *storage_kem_8192128_k2; static unsigned char *test_kem_8192128_k2; static void *storage_kem_8192128_c2; static unsigned char *test_kem_8192128_c2; static void *storage_kem_8192128_t2; static unsigned char *test_kem_8192128_t2; static void test_kem_8192128_impl(long long impl) { unsigned char *p = test_kem_8192128_p; unsigned char *s = test_kem_8192128_s; unsigned char *k = test_kem_8192128_k; unsigned char *c = test_kem_8192128_c; unsigned char *t = test_kem_8192128_t; unsigned char *p2 = test_kem_8192128_p2; unsigned char *s2 = test_kem_8192128_s2; unsigned char *k2 = test_kem_8192128_k2; unsigned char *c2 = test_kem_8192128_c2; unsigned char *t2 = test_kem_8192128_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128_dec(impl); printf("kem_8192128 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128_implementation(impl),mceliece_dispatch_kem_8192128_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128_keypair; crypto_kem_enc = mceliece_kem_8192128_enc; crypto_kem_dec = mceliece_kem_8192128_dec; printf("kem_8192128 selected implementation %s compiler %s\n",mceliece_kem_8192128_implementation(),mceliece_kem_8192128_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_8192128_checksums[checksumbig]); } } static void test_kem_8192128(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128")) return; storage_kem_8192128_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128_p = aligned(storage_kem_8192128_p,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128_s = aligned(storage_kem_8192128_s,crypto_kem_SECRETKEYBYTES); storage_kem_8192128_k = callocplus(crypto_kem_BYTES); test_kem_8192128_k = aligned(storage_kem_8192128_k,crypto_kem_BYTES); storage_kem_8192128_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128_c = aligned(storage_kem_8192128_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128_t = callocplus(crypto_kem_BYTES); test_kem_8192128_t = aligned(storage_kem_8192128_t,crypto_kem_BYTES); storage_kem_8192128_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128_p2 = aligned(storage_kem_8192128_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128_s2 = aligned(storage_kem_8192128_s2,crypto_kem_SECRETKEYBYTES); storage_kem_8192128_k2 = callocplus(crypto_kem_BYTES); test_kem_8192128_k2 = aligned(storage_kem_8192128_k2,crypto_kem_BYTES); storage_kem_8192128_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128_c2 = aligned(storage_kem_8192128_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128_t2 = callocplus(crypto_kem_BYTES); test_kem_8192128_t2 = aligned(storage_kem_8192128_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_8192128 offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128();++impl) forked(test_kem_8192128_impl,impl); ++test_kem_8192128_p; ++test_kem_8192128_s; ++test_kem_8192128_k; ++test_kem_8192128_c; ++test_kem_8192128_t; ++test_kem_8192128_p2; ++test_kem_8192128_s2; ++test_kem_8192128_k2; ++test_kem_8192128_c2; ++test_kem_8192128_t2; } free(storage_kem_8192128_t2); free(storage_kem_8192128_c2); free(storage_kem_8192128_k2); free(storage_kem_8192128_s2); free(storage_kem_8192128_p2); free(storage_kem_8192128_t); free(storage_kem_8192128_c); free(storage_kem_8192128_k); free(storage_kem_8192128_s); free(storage_kem_8192128_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_8192128f_checksums[] = { "2d50dd3ea54c764b5f79505d181c08cefc2276a28c791681cce3a45888c687cc", "717835d0cdf7f4e9a36a53d93116028be3ba3eb7f57bf4913303f3c2e1830900", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_8192128f_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_8192128f_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_8192128f_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_8192128f_BYTES static void *storage_kem_8192128f_p; static unsigned char *test_kem_8192128f_p; static void *storage_kem_8192128f_s; static unsigned char *test_kem_8192128f_s; static void *storage_kem_8192128f_k; static unsigned char *test_kem_8192128f_k; static void *storage_kem_8192128f_c; static unsigned char *test_kem_8192128f_c; static void *storage_kem_8192128f_t; static unsigned char *test_kem_8192128f_t; static void *storage_kem_8192128f_p2; static unsigned char *test_kem_8192128f_p2; static void *storage_kem_8192128f_s2; static unsigned char *test_kem_8192128f_s2; static void *storage_kem_8192128f_k2; static unsigned char *test_kem_8192128f_k2; static void *storage_kem_8192128f_c2; static unsigned char *test_kem_8192128f_c2; static void *storage_kem_8192128f_t2; static unsigned char *test_kem_8192128f_t2; static void test_kem_8192128f_impl(long long impl) { unsigned char *p = test_kem_8192128f_p; unsigned char *s = test_kem_8192128f_s; unsigned char *k = test_kem_8192128f_k; unsigned char *c = test_kem_8192128f_c; unsigned char *t = test_kem_8192128f_t; unsigned char *p2 = test_kem_8192128f_p2; unsigned char *s2 = test_kem_8192128f_s2; unsigned char *k2 = test_kem_8192128f_k2; unsigned char *c2 = test_kem_8192128f_c2; unsigned char *t2 = test_kem_8192128f_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128f_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128f_dec(impl); printf("kem_8192128f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128f_implementation(impl),mceliece_dispatch_kem_8192128f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128f_keypair; crypto_kem_enc = mceliece_kem_8192128f_enc; crypto_kem_dec = mceliece_kem_8192128f_dec; printf("kem_8192128f selected implementation %s compiler %s\n",mceliece_kem_8192128f_implementation(),mceliece_kem_8192128f_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_8192128f_checksums[checksumbig]); } } static void test_kem_8192128f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128f")) return; storage_kem_8192128f_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128f_p = aligned(storage_kem_8192128f_p,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128f_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128f_s = aligned(storage_kem_8192128f_s,crypto_kem_SECRETKEYBYTES); storage_kem_8192128f_k = callocplus(crypto_kem_BYTES); test_kem_8192128f_k = aligned(storage_kem_8192128f_k,crypto_kem_BYTES); storage_kem_8192128f_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128f_c = aligned(storage_kem_8192128f_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128f_t = callocplus(crypto_kem_BYTES); test_kem_8192128f_t = aligned(storage_kem_8192128f_t,crypto_kem_BYTES); storage_kem_8192128f_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128f_p2 = aligned(storage_kem_8192128f_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128f_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128f_s2 = aligned(storage_kem_8192128f_s2,crypto_kem_SECRETKEYBYTES); storage_kem_8192128f_k2 = callocplus(crypto_kem_BYTES); test_kem_8192128f_k2 = aligned(storage_kem_8192128f_k2,crypto_kem_BYTES); storage_kem_8192128f_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128f_c2 = aligned(storage_kem_8192128f_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128f_t2 = callocplus(crypto_kem_BYTES); test_kem_8192128f_t2 = aligned(storage_kem_8192128f_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_8192128f offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128f();++impl) forked(test_kem_8192128f_impl,impl); ++test_kem_8192128f_p; ++test_kem_8192128f_s; ++test_kem_8192128f_k; ++test_kem_8192128f_c; ++test_kem_8192128f_t; ++test_kem_8192128f_p2; ++test_kem_8192128f_s2; ++test_kem_8192128f_k2; ++test_kem_8192128f_c2; ++test_kem_8192128f_t2; } free(storage_kem_8192128f_t2); free(storage_kem_8192128f_c2); free(storage_kem_8192128f_k2); free(storage_kem_8192128f_s2); free(storage_kem_8192128f_p2); free(storage_kem_8192128f_t); free(storage_kem_8192128f_c); free(storage_kem_8192128f_k); free(storage_kem_8192128f_s); free(storage_kem_8192128f_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_8192128pc_checksums[] = { "a9d56a17b9b870e832cddde5c5787b55ada2189992d03eb75e23e710bcb98ccd", "ac060fe5c1bdb9bd96bfa21ad4875cacb61f8e4eed791511020db06c65909811", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_8192128pc_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_8192128pc_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_8192128pc_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_8192128pc_BYTES static void *storage_kem_8192128pc_p; static unsigned char *test_kem_8192128pc_p; static void *storage_kem_8192128pc_s; static unsigned char *test_kem_8192128pc_s; static void *storage_kem_8192128pc_k; static unsigned char *test_kem_8192128pc_k; static void *storage_kem_8192128pc_c; static unsigned char *test_kem_8192128pc_c; static void *storage_kem_8192128pc_t; static unsigned char *test_kem_8192128pc_t; static void *storage_kem_8192128pc_p2; static unsigned char *test_kem_8192128pc_p2; static void *storage_kem_8192128pc_s2; static unsigned char *test_kem_8192128pc_s2; static void *storage_kem_8192128pc_k2; static unsigned char *test_kem_8192128pc_k2; static void *storage_kem_8192128pc_c2; static unsigned char *test_kem_8192128pc_c2; static void *storage_kem_8192128pc_t2; static unsigned char *test_kem_8192128pc_t2; static void test_kem_8192128pc_impl(long long impl) { unsigned char *p = test_kem_8192128pc_p; unsigned char *s = test_kem_8192128pc_s; unsigned char *k = test_kem_8192128pc_k; unsigned char *c = test_kem_8192128pc_c; unsigned char *t = test_kem_8192128pc_t; unsigned char *p2 = test_kem_8192128pc_p2; unsigned char *s2 = test_kem_8192128pc_s2; unsigned char *k2 = test_kem_8192128pc_k2; unsigned char *c2 = test_kem_8192128pc_c2; unsigned char *t2 = test_kem_8192128pc_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128pc_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128pc_dec(impl); printf("kem_8192128pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128pc_implementation(impl),mceliece_dispatch_kem_8192128pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128pc_keypair; crypto_kem_enc = mceliece_kem_8192128pc_enc; crypto_kem_dec = mceliece_kem_8192128pc_dec; printf("kem_8192128pc selected implementation %s compiler %s\n",mceliece_kem_8192128pc_implementation(),mceliece_kem_8192128pc_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_8192128pc_checksums[checksumbig]); } } static void test_kem_8192128pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128pc")) return; storage_kem_8192128pc_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128pc_p = aligned(storage_kem_8192128pc_p,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128pc_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128pc_s = aligned(storage_kem_8192128pc_s,crypto_kem_SECRETKEYBYTES); storage_kem_8192128pc_k = callocplus(crypto_kem_BYTES); test_kem_8192128pc_k = aligned(storage_kem_8192128pc_k,crypto_kem_BYTES); storage_kem_8192128pc_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128pc_c = aligned(storage_kem_8192128pc_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128pc_t = callocplus(crypto_kem_BYTES); test_kem_8192128pc_t = aligned(storage_kem_8192128pc_t,crypto_kem_BYTES); storage_kem_8192128pc_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128pc_p2 = aligned(storage_kem_8192128pc_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128pc_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128pc_s2 = aligned(storage_kem_8192128pc_s2,crypto_kem_SECRETKEYBYTES); storage_kem_8192128pc_k2 = callocplus(crypto_kem_BYTES); test_kem_8192128pc_k2 = aligned(storage_kem_8192128pc_k2,crypto_kem_BYTES); storage_kem_8192128pc_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128pc_c2 = aligned(storage_kem_8192128pc_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128pc_t2 = callocplus(crypto_kem_BYTES); test_kem_8192128pc_t2 = aligned(storage_kem_8192128pc_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_8192128pc offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128pc();++impl) forked(test_kem_8192128pc_impl,impl); ++test_kem_8192128pc_p; ++test_kem_8192128pc_s; ++test_kem_8192128pc_k; ++test_kem_8192128pc_c; ++test_kem_8192128pc_t; ++test_kem_8192128pc_p2; ++test_kem_8192128pc_s2; ++test_kem_8192128pc_k2; ++test_kem_8192128pc_c2; ++test_kem_8192128pc_t2; } free(storage_kem_8192128pc_t2); free(storage_kem_8192128pc_c2); free(storage_kem_8192128pc_k2); free(storage_kem_8192128pc_s2); free(storage_kem_8192128pc_p2); free(storage_kem_8192128pc_t); free(storage_kem_8192128pc_c); free(storage_kem_8192128pc_k); free(storage_kem_8192128pc_s); free(storage_kem_8192128pc_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_8192128pcf_checksums[] = { "fdf47ca26ac3e1a3ae8c2859619cce789420a4af8533ded9e1104d232bd62f5e", "182ec5f02250b7764c121a1b481ec6003c0897f7d772ae7d0bba226660bb99e4", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_8192128pcf_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_8192128pcf_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_8192128pcf_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_8192128pcf_BYTES static void *storage_kem_8192128pcf_p; static unsigned char *test_kem_8192128pcf_p; static void *storage_kem_8192128pcf_s; static unsigned char *test_kem_8192128pcf_s; static void *storage_kem_8192128pcf_k; static unsigned char *test_kem_8192128pcf_k; static void *storage_kem_8192128pcf_c; static unsigned char *test_kem_8192128pcf_c; static void *storage_kem_8192128pcf_t; static unsigned char *test_kem_8192128pcf_t; static void *storage_kem_8192128pcf_p2; static unsigned char *test_kem_8192128pcf_p2; static void *storage_kem_8192128pcf_s2; static unsigned char *test_kem_8192128pcf_s2; static void *storage_kem_8192128pcf_k2; static unsigned char *test_kem_8192128pcf_k2; static void *storage_kem_8192128pcf_c2; static unsigned char *test_kem_8192128pcf_c2; static void *storage_kem_8192128pcf_t2; static unsigned char *test_kem_8192128pcf_t2; static void test_kem_8192128pcf_impl(long long impl) { unsigned char *p = test_kem_8192128pcf_p; unsigned char *s = test_kem_8192128pcf_s; unsigned char *k = test_kem_8192128pcf_k; unsigned char *c = test_kem_8192128pcf_c; unsigned char *t = test_kem_8192128pcf_t; unsigned char *p2 = test_kem_8192128pcf_p2; unsigned char *s2 = test_kem_8192128pcf_s2; unsigned char *k2 = test_kem_8192128pcf_k2; unsigned char *c2 = test_kem_8192128pcf_c2; unsigned char *t2 = test_kem_8192128pcf_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_8192128pcf_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_8192128pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_8192128pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_8192128pcf_dec(impl); printf("kem_8192128pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_8192128pcf_implementation(impl),mceliece_dispatch_kem_8192128pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_8192128pcf_keypair; crypto_kem_enc = mceliece_kem_8192128pcf_enc; crypto_kem_dec = mceliece_kem_8192128pcf_dec; printf("kem_8192128pcf selected implementation %s compiler %s\n",mceliece_kem_8192128pcf_implementation(),mceliece_kem_8192128pcf_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_8192128pcf_checksums[checksumbig]); } } static void test_kem_8192128pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"8192128pcf")) return; storage_kem_8192128pcf_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128pcf_p = aligned(storage_kem_8192128pcf_p,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128pcf_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128pcf_s = aligned(storage_kem_8192128pcf_s,crypto_kem_SECRETKEYBYTES); storage_kem_8192128pcf_k = callocplus(crypto_kem_BYTES); test_kem_8192128pcf_k = aligned(storage_kem_8192128pcf_k,crypto_kem_BYTES); storage_kem_8192128pcf_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128pcf_c = aligned(storage_kem_8192128pcf_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128pcf_t = callocplus(crypto_kem_BYTES); test_kem_8192128pcf_t = aligned(storage_kem_8192128pcf_t,crypto_kem_BYTES); storage_kem_8192128pcf_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_8192128pcf_p2 = aligned(storage_kem_8192128pcf_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_8192128pcf_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_8192128pcf_s2 = aligned(storage_kem_8192128pcf_s2,crypto_kem_SECRETKEYBYTES); storage_kem_8192128pcf_k2 = callocplus(crypto_kem_BYTES); test_kem_8192128pcf_k2 = aligned(storage_kem_8192128pcf_k2,crypto_kem_BYTES); storage_kem_8192128pcf_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_8192128pcf_c2 = aligned(storage_kem_8192128pcf_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_8192128pcf_t2 = callocplus(crypto_kem_BYTES); test_kem_8192128pcf_t2 = aligned(storage_kem_8192128pcf_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_8192128pcf offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_8192128pcf();++impl) forked(test_kem_8192128pcf_impl,impl); ++test_kem_8192128pcf_p; ++test_kem_8192128pcf_s; ++test_kem_8192128pcf_k; ++test_kem_8192128pcf_c; ++test_kem_8192128pcf_t; ++test_kem_8192128pcf_p2; ++test_kem_8192128pcf_s2; ++test_kem_8192128pcf_k2; ++test_kem_8192128pcf_c2; ++test_kem_8192128pcf_t2; } free(storage_kem_8192128pcf_t2); free(storage_kem_8192128pcf_c2); free(storage_kem_8192128pcf_k2); free(storage_kem_8192128pcf_s2); free(storage_kem_8192128pcf_p2); free(storage_kem_8192128pcf_t); free(storage_kem_8192128pcf_c); free(storage_kem_8192128pcf_k); free(storage_kem_8192128pcf_s); free(storage_kem_8192128pcf_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_460896_checksums[] = { "006c110df7fd3ff1852c9096a6514855ef3e715469ecc21d5b6ba14d31057417", "604d5d0be1ec220a2a914735fa5469622cd1f66737cf7e0709b7eaaa1e382f66", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_460896_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_460896_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_460896_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_460896_BYTES static void *storage_kem_460896_p; static unsigned char *test_kem_460896_p; static void *storage_kem_460896_s; static unsigned char *test_kem_460896_s; static void *storage_kem_460896_k; static unsigned char *test_kem_460896_k; static void *storage_kem_460896_c; static unsigned char *test_kem_460896_c; static void *storage_kem_460896_t; static unsigned char *test_kem_460896_t; static void *storage_kem_460896_p2; static unsigned char *test_kem_460896_p2; static void *storage_kem_460896_s2; static unsigned char *test_kem_460896_s2; static void *storage_kem_460896_k2; static unsigned char *test_kem_460896_k2; static void *storage_kem_460896_c2; static unsigned char *test_kem_460896_c2; static void *storage_kem_460896_t2; static unsigned char *test_kem_460896_t2; static void test_kem_460896_impl(long long impl) { unsigned char *p = test_kem_460896_p; unsigned char *s = test_kem_460896_s; unsigned char *k = test_kem_460896_k; unsigned char *c = test_kem_460896_c; unsigned char *t = test_kem_460896_t; unsigned char *p2 = test_kem_460896_p2; unsigned char *s2 = test_kem_460896_s2; unsigned char *k2 = test_kem_460896_k2; unsigned char *c2 = test_kem_460896_c2; unsigned char *t2 = test_kem_460896_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896_dec(impl); printf("kem_460896 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896_implementation(impl),mceliece_dispatch_kem_460896_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896_keypair; crypto_kem_enc = mceliece_kem_460896_enc; crypto_kem_dec = mceliece_kem_460896_dec; printf("kem_460896 selected implementation %s compiler %s\n",mceliece_kem_460896_implementation(),mceliece_kem_460896_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_460896_checksums[checksumbig]); } } static void test_kem_460896(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896")) return; storage_kem_460896_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896_p = aligned(storage_kem_460896_p,crypto_kem_PUBLICKEYBYTES); storage_kem_460896_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896_s = aligned(storage_kem_460896_s,crypto_kem_SECRETKEYBYTES); storage_kem_460896_k = callocplus(crypto_kem_BYTES); test_kem_460896_k = aligned(storage_kem_460896_k,crypto_kem_BYTES); storage_kem_460896_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896_c = aligned(storage_kem_460896_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896_t = callocplus(crypto_kem_BYTES); test_kem_460896_t = aligned(storage_kem_460896_t,crypto_kem_BYTES); storage_kem_460896_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896_p2 = aligned(storage_kem_460896_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_460896_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896_s2 = aligned(storage_kem_460896_s2,crypto_kem_SECRETKEYBYTES); storage_kem_460896_k2 = callocplus(crypto_kem_BYTES); test_kem_460896_k2 = aligned(storage_kem_460896_k2,crypto_kem_BYTES); storage_kem_460896_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896_c2 = aligned(storage_kem_460896_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896_t2 = callocplus(crypto_kem_BYTES); test_kem_460896_t2 = aligned(storage_kem_460896_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_460896 offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_460896();++impl) forked(test_kem_460896_impl,impl); ++test_kem_460896_p; ++test_kem_460896_s; ++test_kem_460896_k; ++test_kem_460896_c; ++test_kem_460896_t; ++test_kem_460896_p2; ++test_kem_460896_s2; ++test_kem_460896_k2; ++test_kem_460896_c2; ++test_kem_460896_t2; } free(storage_kem_460896_t2); free(storage_kem_460896_c2); free(storage_kem_460896_k2); free(storage_kem_460896_s2); free(storage_kem_460896_p2); free(storage_kem_460896_t); free(storage_kem_460896_c); free(storage_kem_460896_k); free(storage_kem_460896_s); free(storage_kem_460896_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_460896f_checksums[] = { "1418b90ac6aa9d36bd3c42c7e8c4ba299eafa45e93a903a383041629fb47f043", "863b850af9436f66906c5824c32165b512352f398f32b2933c424bac34dcdd23", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_460896f_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_460896f_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_460896f_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_460896f_BYTES static void *storage_kem_460896f_p; static unsigned char *test_kem_460896f_p; static void *storage_kem_460896f_s; static unsigned char *test_kem_460896f_s; static void *storage_kem_460896f_k; static unsigned char *test_kem_460896f_k; static void *storage_kem_460896f_c; static unsigned char *test_kem_460896f_c; static void *storage_kem_460896f_t; static unsigned char *test_kem_460896f_t; static void *storage_kem_460896f_p2; static unsigned char *test_kem_460896f_p2; static void *storage_kem_460896f_s2; static unsigned char *test_kem_460896f_s2; static void *storage_kem_460896f_k2; static unsigned char *test_kem_460896f_k2; static void *storage_kem_460896f_c2; static unsigned char *test_kem_460896f_c2; static void *storage_kem_460896f_t2; static unsigned char *test_kem_460896f_t2; static void test_kem_460896f_impl(long long impl) { unsigned char *p = test_kem_460896f_p; unsigned char *s = test_kem_460896f_s; unsigned char *k = test_kem_460896f_k; unsigned char *c = test_kem_460896f_c; unsigned char *t = test_kem_460896f_t; unsigned char *p2 = test_kem_460896f_p2; unsigned char *s2 = test_kem_460896f_s2; unsigned char *k2 = test_kem_460896f_k2; unsigned char *c2 = test_kem_460896f_c2; unsigned char *t2 = test_kem_460896f_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896f_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896f_dec(impl); printf("kem_460896f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896f_implementation(impl),mceliece_dispatch_kem_460896f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896f_keypair; crypto_kem_enc = mceliece_kem_460896f_enc; crypto_kem_dec = mceliece_kem_460896f_dec; printf("kem_460896f selected implementation %s compiler %s\n",mceliece_kem_460896f_implementation(),mceliece_kem_460896f_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_460896f_checksums[checksumbig]); } } static void test_kem_460896f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896f")) return; storage_kem_460896f_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896f_p = aligned(storage_kem_460896f_p,crypto_kem_PUBLICKEYBYTES); storage_kem_460896f_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896f_s = aligned(storage_kem_460896f_s,crypto_kem_SECRETKEYBYTES); storage_kem_460896f_k = callocplus(crypto_kem_BYTES); test_kem_460896f_k = aligned(storage_kem_460896f_k,crypto_kem_BYTES); storage_kem_460896f_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896f_c = aligned(storage_kem_460896f_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896f_t = callocplus(crypto_kem_BYTES); test_kem_460896f_t = aligned(storage_kem_460896f_t,crypto_kem_BYTES); storage_kem_460896f_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896f_p2 = aligned(storage_kem_460896f_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_460896f_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896f_s2 = aligned(storage_kem_460896f_s2,crypto_kem_SECRETKEYBYTES); storage_kem_460896f_k2 = callocplus(crypto_kem_BYTES); test_kem_460896f_k2 = aligned(storage_kem_460896f_k2,crypto_kem_BYTES); storage_kem_460896f_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896f_c2 = aligned(storage_kem_460896f_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896f_t2 = callocplus(crypto_kem_BYTES); test_kem_460896f_t2 = aligned(storage_kem_460896f_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_460896f offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_460896f();++impl) forked(test_kem_460896f_impl,impl); ++test_kem_460896f_p; ++test_kem_460896f_s; ++test_kem_460896f_k; ++test_kem_460896f_c; ++test_kem_460896f_t; ++test_kem_460896f_p2; ++test_kem_460896f_s2; ++test_kem_460896f_k2; ++test_kem_460896f_c2; ++test_kem_460896f_t2; } free(storage_kem_460896f_t2); free(storage_kem_460896f_c2); free(storage_kem_460896f_k2); free(storage_kem_460896f_s2); free(storage_kem_460896f_p2); free(storage_kem_460896f_t); free(storage_kem_460896f_c); free(storage_kem_460896f_k); free(storage_kem_460896f_s); free(storage_kem_460896f_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_460896pc_checksums[] = { "e27bb3f53c37eaaef460488d21750a80baf3874b0b26b23e510325e45c31c560", "99fe694290b1e02673ad7f1b69ce51aa94406ba23cdf77e69012f0b2fbcebaba", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_460896pc_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_460896pc_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_460896pc_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_460896pc_BYTES static void *storage_kem_460896pc_p; static unsigned char *test_kem_460896pc_p; static void *storage_kem_460896pc_s; static unsigned char *test_kem_460896pc_s; static void *storage_kem_460896pc_k; static unsigned char *test_kem_460896pc_k; static void *storage_kem_460896pc_c; static unsigned char *test_kem_460896pc_c; static void *storage_kem_460896pc_t; static unsigned char *test_kem_460896pc_t; static void *storage_kem_460896pc_p2; static unsigned char *test_kem_460896pc_p2; static void *storage_kem_460896pc_s2; static unsigned char *test_kem_460896pc_s2; static void *storage_kem_460896pc_k2; static unsigned char *test_kem_460896pc_k2; static void *storage_kem_460896pc_c2; static unsigned char *test_kem_460896pc_c2; static void *storage_kem_460896pc_t2; static unsigned char *test_kem_460896pc_t2; static void test_kem_460896pc_impl(long long impl) { unsigned char *p = test_kem_460896pc_p; unsigned char *s = test_kem_460896pc_s; unsigned char *k = test_kem_460896pc_k; unsigned char *c = test_kem_460896pc_c; unsigned char *t = test_kem_460896pc_t; unsigned char *p2 = test_kem_460896pc_p2; unsigned char *s2 = test_kem_460896pc_s2; unsigned char *k2 = test_kem_460896pc_k2; unsigned char *c2 = test_kem_460896pc_c2; unsigned char *t2 = test_kem_460896pc_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896pc_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896pc_dec(impl); printf("kem_460896pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896pc_implementation(impl),mceliece_dispatch_kem_460896pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896pc_keypair; crypto_kem_enc = mceliece_kem_460896pc_enc; crypto_kem_dec = mceliece_kem_460896pc_dec; printf("kem_460896pc selected implementation %s compiler %s\n",mceliece_kem_460896pc_implementation(),mceliece_kem_460896pc_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_460896pc_checksums[checksumbig]); } } static void test_kem_460896pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896pc")) return; storage_kem_460896pc_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896pc_p = aligned(storage_kem_460896pc_p,crypto_kem_PUBLICKEYBYTES); storage_kem_460896pc_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896pc_s = aligned(storage_kem_460896pc_s,crypto_kem_SECRETKEYBYTES); storage_kem_460896pc_k = callocplus(crypto_kem_BYTES); test_kem_460896pc_k = aligned(storage_kem_460896pc_k,crypto_kem_BYTES); storage_kem_460896pc_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896pc_c = aligned(storage_kem_460896pc_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896pc_t = callocplus(crypto_kem_BYTES); test_kem_460896pc_t = aligned(storage_kem_460896pc_t,crypto_kem_BYTES); storage_kem_460896pc_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896pc_p2 = aligned(storage_kem_460896pc_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_460896pc_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896pc_s2 = aligned(storage_kem_460896pc_s2,crypto_kem_SECRETKEYBYTES); storage_kem_460896pc_k2 = callocplus(crypto_kem_BYTES); test_kem_460896pc_k2 = aligned(storage_kem_460896pc_k2,crypto_kem_BYTES); storage_kem_460896pc_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896pc_c2 = aligned(storage_kem_460896pc_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896pc_t2 = callocplus(crypto_kem_BYTES); test_kem_460896pc_t2 = aligned(storage_kem_460896pc_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_460896pc offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_460896pc();++impl) forked(test_kem_460896pc_impl,impl); ++test_kem_460896pc_p; ++test_kem_460896pc_s; ++test_kem_460896pc_k; ++test_kem_460896pc_c; ++test_kem_460896pc_t; ++test_kem_460896pc_p2; ++test_kem_460896pc_s2; ++test_kem_460896pc_k2; ++test_kem_460896pc_c2; ++test_kem_460896pc_t2; } free(storage_kem_460896pc_t2); free(storage_kem_460896pc_c2); free(storage_kem_460896pc_k2); free(storage_kem_460896pc_s2); free(storage_kem_460896pc_p2); free(storage_kem_460896pc_t); free(storage_kem_460896pc_c); free(storage_kem_460896pc_k); free(storage_kem_460896pc_s); free(storage_kem_460896pc_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_460896pcf_checksums[] = { "1980e3f38d8258eca9d8d4300ac8dd6a6cde2f2c10c5e7b589971972531c8505", "063a2ecf26e027499a9f6b4e8344800819c28bf094926af1e3ec45107175ce53", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_460896pcf_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_460896pcf_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_460896pcf_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_460896pcf_BYTES static void *storage_kem_460896pcf_p; static unsigned char *test_kem_460896pcf_p; static void *storage_kem_460896pcf_s; static unsigned char *test_kem_460896pcf_s; static void *storage_kem_460896pcf_k; static unsigned char *test_kem_460896pcf_k; static void *storage_kem_460896pcf_c; static unsigned char *test_kem_460896pcf_c; static void *storage_kem_460896pcf_t; static unsigned char *test_kem_460896pcf_t; static void *storage_kem_460896pcf_p2; static unsigned char *test_kem_460896pcf_p2; static void *storage_kem_460896pcf_s2; static unsigned char *test_kem_460896pcf_s2; static void *storage_kem_460896pcf_k2; static unsigned char *test_kem_460896pcf_k2; static void *storage_kem_460896pcf_c2; static unsigned char *test_kem_460896pcf_c2; static void *storage_kem_460896pcf_t2; static unsigned char *test_kem_460896pcf_t2; static void test_kem_460896pcf_impl(long long impl) { unsigned char *p = test_kem_460896pcf_p; unsigned char *s = test_kem_460896pcf_s; unsigned char *k = test_kem_460896pcf_k; unsigned char *c = test_kem_460896pcf_c; unsigned char *t = test_kem_460896pcf_t; unsigned char *p2 = test_kem_460896pcf_p2; unsigned char *s2 = test_kem_460896pcf_s2; unsigned char *k2 = test_kem_460896pcf_k2; unsigned char *c2 = test_kem_460896pcf_c2; unsigned char *t2 = test_kem_460896pcf_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_460896pcf_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_460896pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_460896pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_460896pcf_dec(impl); printf("kem_460896pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_460896pcf_implementation(impl),mceliece_dispatch_kem_460896pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_460896pcf_keypair; crypto_kem_enc = mceliece_kem_460896pcf_enc; crypto_kem_dec = mceliece_kem_460896pcf_dec; printf("kem_460896pcf selected implementation %s compiler %s\n",mceliece_kem_460896pcf_implementation(),mceliece_kem_460896pcf_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_460896pcf_checksums[checksumbig]); } } static void test_kem_460896pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"460896pcf")) return; storage_kem_460896pcf_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896pcf_p = aligned(storage_kem_460896pcf_p,crypto_kem_PUBLICKEYBYTES); storage_kem_460896pcf_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896pcf_s = aligned(storage_kem_460896pcf_s,crypto_kem_SECRETKEYBYTES); storage_kem_460896pcf_k = callocplus(crypto_kem_BYTES); test_kem_460896pcf_k = aligned(storage_kem_460896pcf_k,crypto_kem_BYTES); storage_kem_460896pcf_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896pcf_c = aligned(storage_kem_460896pcf_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896pcf_t = callocplus(crypto_kem_BYTES); test_kem_460896pcf_t = aligned(storage_kem_460896pcf_t,crypto_kem_BYTES); storage_kem_460896pcf_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_460896pcf_p2 = aligned(storage_kem_460896pcf_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_460896pcf_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_460896pcf_s2 = aligned(storage_kem_460896pcf_s2,crypto_kem_SECRETKEYBYTES); storage_kem_460896pcf_k2 = callocplus(crypto_kem_BYTES); test_kem_460896pcf_k2 = aligned(storage_kem_460896pcf_k2,crypto_kem_BYTES); storage_kem_460896pcf_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_460896pcf_c2 = aligned(storage_kem_460896pcf_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_460896pcf_t2 = callocplus(crypto_kem_BYTES); test_kem_460896pcf_t2 = aligned(storage_kem_460896pcf_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_460896pcf offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_460896pcf();++impl) forked(test_kem_460896pcf_impl,impl); ++test_kem_460896pcf_p; ++test_kem_460896pcf_s; ++test_kem_460896pcf_k; ++test_kem_460896pcf_c; ++test_kem_460896pcf_t; ++test_kem_460896pcf_p2; ++test_kem_460896pcf_s2; ++test_kem_460896pcf_k2; ++test_kem_460896pcf_c2; ++test_kem_460896pcf_t2; } free(storage_kem_460896pcf_t2); free(storage_kem_460896pcf_c2); free(storage_kem_460896pcf_k2); free(storage_kem_460896pcf_s2); free(storage_kem_460896pcf_p2); free(storage_kem_460896pcf_t); free(storage_kem_460896pcf_c); free(storage_kem_460896pcf_k); free(storage_kem_460896pcf_s); free(storage_kem_460896pcf_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_348864_checksums[] = { "2f36e1825115c5accc9a6ea609dec708f83be85e7fe448637bd502de50a1dd91", "df7965299cab8d4669eb29ebe87a2f61a539aa016a8dcda268a8cd595bf6d8da", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_348864_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_348864_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_348864_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_348864_BYTES static void *storage_kem_348864_p; static unsigned char *test_kem_348864_p; static void *storage_kem_348864_s; static unsigned char *test_kem_348864_s; static void *storage_kem_348864_k; static unsigned char *test_kem_348864_k; static void *storage_kem_348864_c; static unsigned char *test_kem_348864_c; static void *storage_kem_348864_t; static unsigned char *test_kem_348864_t; static void *storage_kem_348864_p2; static unsigned char *test_kem_348864_p2; static void *storage_kem_348864_s2; static unsigned char *test_kem_348864_s2; static void *storage_kem_348864_k2; static unsigned char *test_kem_348864_k2; static void *storage_kem_348864_c2; static unsigned char *test_kem_348864_c2; static void *storage_kem_348864_t2; static unsigned char *test_kem_348864_t2; static void test_kem_348864_impl(long long impl) { unsigned char *p = test_kem_348864_p; unsigned char *s = test_kem_348864_s; unsigned char *k = test_kem_348864_k; unsigned char *c = test_kem_348864_c; unsigned char *t = test_kem_348864_t; unsigned char *p2 = test_kem_348864_p2; unsigned char *s2 = test_kem_348864_s2; unsigned char *k2 = test_kem_348864_k2; unsigned char *c2 = test_kem_348864_c2; unsigned char *t2 = test_kem_348864_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864_dec(impl); printf("kem_348864 %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864_implementation(impl),mceliece_dispatch_kem_348864_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864_keypair; crypto_kem_enc = mceliece_kem_348864_enc; crypto_kem_dec = mceliece_kem_348864_dec; printf("kem_348864 selected implementation %s compiler %s\n",mceliece_kem_348864_implementation(),mceliece_kem_348864_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_348864_checksums[checksumbig]); } } static void test_kem_348864(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864")) return; storage_kem_348864_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864_p = aligned(storage_kem_348864_p,crypto_kem_PUBLICKEYBYTES); storage_kem_348864_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864_s = aligned(storage_kem_348864_s,crypto_kem_SECRETKEYBYTES); storage_kem_348864_k = callocplus(crypto_kem_BYTES); test_kem_348864_k = aligned(storage_kem_348864_k,crypto_kem_BYTES); storage_kem_348864_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864_c = aligned(storage_kem_348864_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864_t = callocplus(crypto_kem_BYTES); test_kem_348864_t = aligned(storage_kem_348864_t,crypto_kem_BYTES); storage_kem_348864_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864_p2 = aligned(storage_kem_348864_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_348864_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864_s2 = aligned(storage_kem_348864_s2,crypto_kem_SECRETKEYBYTES); storage_kem_348864_k2 = callocplus(crypto_kem_BYTES); test_kem_348864_k2 = aligned(storage_kem_348864_k2,crypto_kem_BYTES); storage_kem_348864_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864_c2 = aligned(storage_kem_348864_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864_t2 = callocplus(crypto_kem_BYTES); test_kem_348864_t2 = aligned(storage_kem_348864_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_348864 offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_348864();++impl) forked(test_kem_348864_impl,impl); ++test_kem_348864_p; ++test_kem_348864_s; ++test_kem_348864_k; ++test_kem_348864_c; ++test_kem_348864_t; ++test_kem_348864_p2; ++test_kem_348864_s2; ++test_kem_348864_k2; ++test_kem_348864_c2; ++test_kem_348864_t2; } free(storage_kem_348864_t2); free(storage_kem_348864_c2); free(storage_kem_348864_k2); free(storage_kem_348864_s2); free(storage_kem_348864_p2); free(storage_kem_348864_t); free(storage_kem_348864_c); free(storage_kem_348864_k); free(storage_kem_348864_s); free(storage_kem_348864_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_348864f_checksums[] = { "5ad76eff6b5ccaedc1615e9795880cfd79b44c4247db4b8a13684c507a5db437", "471a096310df17d7650c5d1a2e798909598b3b16652c70eb722be84673cf2f8f", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_348864f_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_348864f_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_348864f_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_348864f_BYTES static void *storage_kem_348864f_p; static unsigned char *test_kem_348864f_p; static void *storage_kem_348864f_s; static unsigned char *test_kem_348864f_s; static void *storage_kem_348864f_k; static unsigned char *test_kem_348864f_k; static void *storage_kem_348864f_c; static unsigned char *test_kem_348864f_c; static void *storage_kem_348864f_t; static unsigned char *test_kem_348864f_t; static void *storage_kem_348864f_p2; static unsigned char *test_kem_348864f_p2; static void *storage_kem_348864f_s2; static unsigned char *test_kem_348864f_s2; static void *storage_kem_348864f_k2; static unsigned char *test_kem_348864f_k2; static void *storage_kem_348864f_c2; static unsigned char *test_kem_348864f_c2; static void *storage_kem_348864f_t2; static unsigned char *test_kem_348864f_t2; static void test_kem_348864f_impl(long long impl) { unsigned char *p = test_kem_348864f_p; unsigned char *s = test_kem_348864f_s; unsigned char *k = test_kem_348864f_k; unsigned char *c = test_kem_348864f_c; unsigned char *t = test_kem_348864f_t; unsigned char *p2 = test_kem_348864f_p2; unsigned char *s2 = test_kem_348864f_s2; unsigned char *k2 = test_kem_348864f_k2; unsigned char *c2 = test_kem_348864f_c2; unsigned char *t2 = test_kem_348864f_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864f_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864f_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864f_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864f_dec(impl); printf("kem_348864f %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864f_implementation(impl),mceliece_dispatch_kem_348864f_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864f_keypair; crypto_kem_enc = mceliece_kem_348864f_enc; crypto_kem_dec = mceliece_kem_348864f_dec; printf("kem_348864f selected implementation %s compiler %s\n",mceliece_kem_348864f_implementation(),mceliece_kem_348864f_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_348864f_checksums[checksumbig]); } } static void test_kem_348864f(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864f")) return; storage_kem_348864f_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864f_p = aligned(storage_kem_348864f_p,crypto_kem_PUBLICKEYBYTES); storage_kem_348864f_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864f_s = aligned(storage_kem_348864f_s,crypto_kem_SECRETKEYBYTES); storage_kem_348864f_k = callocplus(crypto_kem_BYTES); test_kem_348864f_k = aligned(storage_kem_348864f_k,crypto_kem_BYTES); storage_kem_348864f_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864f_c = aligned(storage_kem_348864f_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864f_t = callocplus(crypto_kem_BYTES); test_kem_348864f_t = aligned(storage_kem_348864f_t,crypto_kem_BYTES); storage_kem_348864f_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864f_p2 = aligned(storage_kem_348864f_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_348864f_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864f_s2 = aligned(storage_kem_348864f_s2,crypto_kem_SECRETKEYBYTES); storage_kem_348864f_k2 = callocplus(crypto_kem_BYTES); test_kem_348864f_k2 = aligned(storage_kem_348864f_k2,crypto_kem_BYTES); storage_kem_348864f_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864f_c2 = aligned(storage_kem_348864f_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864f_t2 = callocplus(crypto_kem_BYTES); test_kem_348864f_t2 = aligned(storage_kem_348864f_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_348864f offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_348864f();++impl) forked(test_kem_348864f_impl,impl); ++test_kem_348864f_p; ++test_kem_348864f_s; ++test_kem_348864f_k; ++test_kem_348864f_c; ++test_kem_348864f_t; ++test_kem_348864f_p2; ++test_kem_348864f_s2; ++test_kem_348864f_k2; ++test_kem_348864f_c2; ++test_kem_348864f_t2; } free(storage_kem_348864f_t2); free(storage_kem_348864f_c2); free(storage_kem_348864f_k2); free(storage_kem_348864f_s2); free(storage_kem_348864f_p2); free(storage_kem_348864f_t); free(storage_kem_348864f_c); free(storage_kem_348864f_k); free(storage_kem_348864f_s); free(storage_kem_348864f_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_348864pc_checksums[] = { "ddfa65df30bee9c97e153089d24cce158a7979aa01ebdbb7bf374da13bd81feb", "9866af598e967b1b3903d9e125bf756a92aed474f750678238b2bb52129cd213", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_348864pc_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_348864pc_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_348864pc_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_348864pc_BYTES static void *storage_kem_348864pc_p; static unsigned char *test_kem_348864pc_p; static void *storage_kem_348864pc_s; static unsigned char *test_kem_348864pc_s; static void *storage_kem_348864pc_k; static unsigned char *test_kem_348864pc_k; static void *storage_kem_348864pc_c; static unsigned char *test_kem_348864pc_c; static void *storage_kem_348864pc_t; static unsigned char *test_kem_348864pc_t; static void *storage_kem_348864pc_p2; static unsigned char *test_kem_348864pc_p2; static void *storage_kem_348864pc_s2; static unsigned char *test_kem_348864pc_s2; static void *storage_kem_348864pc_k2; static unsigned char *test_kem_348864pc_k2; static void *storage_kem_348864pc_c2; static unsigned char *test_kem_348864pc_c2; static void *storage_kem_348864pc_t2; static unsigned char *test_kem_348864pc_t2; static void test_kem_348864pc_impl(long long impl) { unsigned char *p = test_kem_348864pc_p; unsigned char *s = test_kem_348864pc_s; unsigned char *k = test_kem_348864pc_k; unsigned char *c = test_kem_348864pc_c; unsigned char *t = test_kem_348864pc_t; unsigned char *p2 = test_kem_348864pc_p2; unsigned char *s2 = test_kem_348864pc_s2; unsigned char *k2 = test_kem_348864pc_k2; unsigned char *c2 = test_kem_348864pc_c2; unsigned char *t2 = test_kem_348864pc_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864pc_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864pc_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864pc_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864pc_dec(impl); printf("kem_348864pc %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864pc_implementation(impl),mceliece_dispatch_kem_348864pc_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864pc_keypair; crypto_kem_enc = mceliece_kem_348864pc_enc; crypto_kem_dec = mceliece_kem_348864pc_dec; printf("kem_348864pc selected implementation %s compiler %s\n",mceliece_kem_348864pc_implementation(),mceliece_kem_348864pc_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_348864pc_checksums[checksumbig]); } } static void test_kem_348864pc(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864pc")) return; storage_kem_348864pc_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864pc_p = aligned(storage_kem_348864pc_p,crypto_kem_PUBLICKEYBYTES); storage_kem_348864pc_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864pc_s = aligned(storage_kem_348864pc_s,crypto_kem_SECRETKEYBYTES); storage_kem_348864pc_k = callocplus(crypto_kem_BYTES); test_kem_348864pc_k = aligned(storage_kem_348864pc_k,crypto_kem_BYTES); storage_kem_348864pc_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864pc_c = aligned(storage_kem_348864pc_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864pc_t = callocplus(crypto_kem_BYTES); test_kem_348864pc_t = aligned(storage_kem_348864pc_t,crypto_kem_BYTES); storage_kem_348864pc_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864pc_p2 = aligned(storage_kem_348864pc_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_348864pc_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864pc_s2 = aligned(storage_kem_348864pc_s2,crypto_kem_SECRETKEYBYTES); storage_kem_348864pc_k2 = callocplus(crypto_kem_BYTES); test_kem_348864pc_k2 = aligned(storage_kem_348864pc_k2,crypto_kem_BYTES); storage_kem_348864pc_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864pc_c2 = aligned(storage_kem_348864pc_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864pc_t2 = callocplus(crypto_kem_BYTES); test_kem_348864pc_t2 = aligned(storage_kem_348864pc_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_348864pc offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_348864pc();++impl) forked(test_kem_348864pc_impl,impl); ++test_kem_348864pc_p; ++test_kem_348864pc_s; ++test_kem_348864pc_k; ++test_kem_348864pc_c; ++test_kem_348864pc_t; ++test_kem_348864pc_p2; ++test_kem_348864pc_s2; ++test_kem_348864pc_k2; ++test_kem_348864pc_c2; ++test_kem_348864pc_t2; } free(storage_kem_348864pc_t2); free(storage_kem_348864pc_c2); free(storage_kem_348864pc_k2); free(storage_kem_348864pc_s2); free(storage_kem_348864pc_p2); free(storage_kem_348864pc_t); free(storage_kem_348864pc_c); free(storage_kem_348864pc_k); free(storage_kem_348864pc_s); free(storage_kem_348864pc_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES static const char *kem_348864pcf_checksums[] = { "4dcfc56d5e162873f227befd1e7c51f2b317f9ccf811e931e86e2fcdeea6c10e", "48fffebf6cd92a688b4724d88cf989ab199066040c7c62202dab6f30ef188d68", } ; static void (*crypto_kem_keypair)(unsigned char *,unsigned char *); static int (*crypto_kem_enc)(unsigned char *,unsigned char *,const unsigned char *); static int (*crypto_kem_dec)(unsigned char *,const unsigned char *,const unsigned char *); #define crypto_kem_PUBLICKEYBYTES mceliece_kem_348864pcf_PUBLICKEYBYTES #define crypto_kem_SECRETKEYBYTES mceliece_kem_348864pcf_SECRETKEYBYTES #define crypto_kem_CIPHERTEXTBYTES mceliece_kem_348864pcf_CIPHERTEXTBYTES #define crypto_kem_BYTES mceliece_kem_348864pcf_BYTES static void *storage_kem_348864pcf_p; static unsigned char *test_kem_348864pcf_p; static void *storage_kem_348864pcf_s; static unsigned char *test_kem_348864pcf_s; static void *storage_kem_348864pcf_k; static unsigned char *test_kem_348864pcf_k; static void *storage_kem_348864pcf_c; static unsigned char *test_kem_348864pcf_c; static void *storage_kem_348864pcf_t; static unsigned char *test_kem_348864pcf_t; static void *storage_kem_348864pcf_p2; static unsigned char *test_kem_348864pcf_p2; static void *storage_kem_348864pcf_s2; static unsigned char *test_kem_348864pcf_s2; static void *storage_kem_348864pcf_k2; static unsigned char *test_kem_348864pcf_k2; static void *storage_kem_348864pcf_c2; static unsigned char *test_kem_348864pcf_c2; static void *storage_kem_348864pcf_t2; static unsigned char *test_kem_348864pcf_t2; static void test_kem_348864pcf_impl(long long impl) { unsigned char *p = test_kem_348864pcf_p; unsigned char *s = test_kem_348864pcf_s; unsigned char *k = test_kem_348864pcf_k; unsigned char *c = test_kem_348864pcf_c; unsigned char *t = test_kem_348864pcf_t; unsigned char *p2 = test_kem_348864pcf_p2; unsigned char *s2 = test_kem_348864pcf_s2; unsigned char *k2 = test_kem_348864pcf_k2; unsigned char *c2 = test_kem_348864pcf_c2; unsigned char *t2 = test_kem_348864pcf_t2; long long plen = crypto_kem_PUBLICKEYBYTES; long long slen = crypto_kem_SECRETKEYBYTES; long long klen = crypto_kem_BYTES; long long clen = crypto_kem_CIPHERTEXTBYTES; long long tlen = crypto_kem_BYTES; if (targeti && strcmp(targeti,mceliece_dispatch_kem_348864pcf_implementation(impl))) return; if (impl >= 0) { crypto_kem_keypair = mceliece_dispatch_kem_348864pcf_keypair(impl); crypto_kem_enc = mceliece_dispatch_kem_348864pcf_enc(impl); crypto_kem_dec = mceliece_dispatch_kem_348864pcf_dec(impl); printf("kem_348864pcf %lld implementation %s compiler %s\n",impl,mceliece_dispatch_kem_348864pcf_implementation(impl),mceliece_dispatch_kem_348864pcf_compiler(impl)); } else { crypto_kem_keypair = mceliece_kem_348864pcf_keypair; crypto_kem_enc = mceliece_kem_348864pcf_enc; crypto_kem_dec = mceliece_kem_348864pcf_dec; printf("kem_348864pcf selected implementation %s compiler %s\n",mceliece_kem_348864pcf_implementation(),mceliece_kem_348864pcf_compiler()); } for (long long checksumbig = 0;checksumbig < 2;++checksumbig) { long long loops = checksumbig ? 64 : 8; checksum_clear(); for (long long loop = 0;loop < loops;++loop) { int result; output_prepare(p2,p,plen); output_prepare(s2,s,slen); crypto_kem_keypair(p,s); checksum(p,plen); checksum(s,slen); output_compare(p2,p,plen,"crypto_kem_keypair"); output_compare(s2,s,slen,"crypto_kem_keypair"); output_prepare(c2,c,clen); output_prepare(k2,k,klen); memcpy(p2,p,plen); double_canary(p2,p,plen); result = crypto_kem_enc(c,k,p); if (result != 0) fail("failure: crypto_kem_enc returns nonzero\n"); checksum(c,clen); checksum(k,klen); output_compare(c2,c,clen,"crypto_kem_enc"); output_compare(k2,k,klen,"crypto_kem_enc"); input_compare(p2,p,plen,"crypto_kem_enc"); output_prepare(t2,t,tlen); memcpy(c2,c,clen); double_canary(c2,c,clen); memcpy(s2,s,slen); double_canary(s2,s,slen); result = crypto_kem_dec(t,c,s); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t,k,klen) != 0) fail("failure: crypto_kem_dec does not match k\n"); checksum(t,tlen); output_compare(t2,t,tlen,"crypto_kem_dec"); input_compare(c2,c,clen,"crypto_kem_dec"); input_compare(s2,s,slen,"crypto_kem_dec"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(t2,c2,s2); if (result != 0) fail("failure: crypto_kem_dec returns nonzero\n"); if (memcmp(t2,t,tlen) != 0) fail("failure: crypto_kem_dec is nondeterministic\n"); double_canary(t2,t,tlen); double_canary(c2,c,clen); double_canary(s2,s,slen); result = crypto_kem_dec(c2,c2,s); if (result != 0) fail("failure: crypto_kem_dec with c=t overlap returns nonzero\n"); if (memcmp(c2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle c=t overlap\n"); memcpy(c2,c,clen); result = crypto_kem_dec(s2,c,s2); if (result != 0) fail("failure: crypto_kem_dec with s=t overlap returns nonzero\n"); if (memcmp(s2,t,tlen) != 0) fail("failure: crypto_kem_dec does not handle s=t overlap\n"); memcpy(s2,s,slen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); c[myrandom() % clen] += 1 + (myrandom() % 255); if (crypto_kem_dec(t,c,s) == 0) checksum(t,tlen); else checksum(c,clen); } checksum_expected(kem_348864pcf_checksums[checksumbig]); } } static void test_kem_348864pcf(void) { if (targeto && strcmp(targeto,"kem")) return; if (targetp && strcmp(targetp,"348864pcf")) return; storage_kem_348864pcf_p = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864pcf_p = aligned(storage_kem_348864pcf_p,crypto_kem_PUBLICKEYBYTES); storage_kem_348864pcf_s = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864pcf_s = aligned(storage_kem_348864pcf_s,crypto_kem_SECRETKEYBYTES); storage_kem_348864pcf_k = callocplus(crypto_kem_BYTES); test_kem_348864pcf_k = aligned(storage_kem_348864pcf_k,crypto_kem_BYTES); storage_kem_348864pcf_c = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864pcf_c = aligned(storage_kem_348864pcf_c,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864pcf_t = callocplus(crypto_kem_BYTES); test_kem_348864pcf_t = aligned(storage_kem_348864pcf_t,crypto_kem_BYTES); storage_kem_348864pcf_p2 = callocplus(crypto_kem_PUBLICKEYBYTES); test_kem_348864pcf_p2 = aligned(storage_kem_348864pcf_p2,crypto_kem_PUBLICKEYBYTES); storage_kem_348864pcf_s2 = callocplus(crypto_kem_SECRETKEYBYTES); test_kem_348864pcf_s2 = aligned(storage_kem_348864pcf_s2,crypto_kem_SECRETKEYBYTES); storage_kem_348864pcf_k2 = callocplus(crypto_kem_BYTES); test_kem_348864pcf_k2 = aligned(storage_kem_348864pcf_k2,crypto_kem_BYTES); storage_kem_348864pcf_c2 = callocplus(crypto_kem_CIPHERTEXTBYTES); test_kem_348864pcf_c2 = aligned(storage_kem_348864pcf_c2,crypto_kem_CIPHERTEXTBYTES); storage_kem_348864pcf_t2 = callocplus(crypto_kem_BYTES); test_kem_348864pcf_t2 = aligned(storage_kem_348864pcf_t2,crypto_kem_BYTES); for (long long offset = 0;offset < 2;++offset) { printf("kem_348864pcf offset %lld\n",offset); for (long long impl = -1;impl < mceliece_numimpl_kem_348864pcf();++impl) forked(test_kem_348864pcf_impl,impl); ++test_kem_348864pcf_p; ++test_kem_348864pcf_s; ++test_kem_348864pcf_k; ++test_kem_348864pcf_c; ++test_kem_348864pcf_t; ++test_kem_348864pcf_p2; ++test_kem_348864pcf_s2; ++test_kem_348864pcf_k2; ++test_kem_348864pcf_c2; ++test_kem_348864pcf_t2; } free(storage_kem_348864pcf_t2); free(storage_kem_348864pcf_c2); free(storage_kem_348864pcf_k2); free(storage_kem_348864pcf_s2); free(storage_kem_348864pcf_p2); free(storage_kem_348864pcf_t); free(storage_kem_348864pcf_c); free(storage_kem_348864pcf_k); free(storage_kem_348864pcf_s); free(storage_kem_348864pcf_p); } #undef crypto_kem_PUBLICKEYBYTES #undef crypto_kem_SECRETKEYBYTES #undef crypto_kem_CIPHERTEXTBYTES #undef crypto_kem_BYTES /* ----- top level */ #include "print_cpuid.inc" int main(int argc,char **argv) { setvbuf(stdout,0,_IOLBF,0); printf("mceliece version %s\n",mceliece_version); printf("mceliece arch %s\n",mceliece_arch); print_cpuid(); if (*argv) ++argv; if (*argv) { targeto = *argv++; if (*argv) { targetp = *argv++; if (*argv) { targeti = *argv++; } } } test_xof_shake256(); test_sort_int32(); test_kem_6960119(); test_kem_6960119f(); test_kem_6960119pc(); test_kem_6960119pcf(); test_kem_6688128(); test_kem_6688128f(); test_kem_6688128pc(); test_kem_6688128pcf(); test_kem_8192128(); test_kem_8192128f(); test_kem_8192128pc(); test_kem_8192128pcf(); test_kem_460896(); test_kem_460896f(); test_kem_460896pc(); test_kem_460896pcf(); test_kem_348864(); test_kem_348864f(); test_kem_348864pc(); test_kem_348864pcf(); if (!ok) { printf("some tests failed\n"); return 100; } printf("all tests succeeded\n"); return 0; } libmceliece-20230612/command/mceliece348864-dec.c0000644000000000000000000000321514441554466017506 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece348864_SECRETKEYBYTES]; static unsigned char c[mceliece348864_CIPHERTEXTBYTES]; static unsigned char k[mceliece348864_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece348864-dec: usage: mceliece348864-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece348864_PUBLICKEYBYTES]; static unsigned char c[mceliece348864_CIPHERTEXTBYTES]; static unsigned char k[mceliece348864_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece348864-enc: usage: mceliece348864-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece348864_PUBLICKEYBYTES]; static unsigned char sk[mceliece348864_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece348864-keypair: usage: mceliece348864-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece348864-keypair: usage: mceliece348864-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece348864_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece348864f-keypair.c0000644000000000000000000000257214441554466020572 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece348864f_PUBLICKEYBYTES]; static unsigned char sk[mceliece348864f_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864f-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864f-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece348864f-keypair: usage: mceliece348864f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece348864f-keypair: usage: mceliece348864f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece348864f_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece348864pc-dec.c0000644000000000000000000000324114441554466020030 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece348864pc_SECRETKEYBYTES]; static unsigned char c[mceliece348864pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece348864pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864pc-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864pc-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece348864pc-dec: usage: mceliece348864pc-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece348864pc_PUBLICKEYBYTES]; static unsigned char c[mceliece348864pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece348864pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864pc-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864pc-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece348864pc-enc: usage: mceliece348864pc-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece348864pc_PUBLICKEYBYTES]; static unsigned char sk[mceliece348864pc_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864pc-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864pc-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece348864pc-keypair: usage: mceliece348864pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece348864pc-keypair: usage: mceliece348864pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece348864pc_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece348864pcf-keypair.c0000644000000000000000000000261414441554466021112 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece348864pcf_PUBLICKEYBYTES]; static unsigned char sk[mceliece348864pcf_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece348864pcf-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece348864pcf-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece348864pcf-keypair: usage: mceliece348864pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece348864pcf-keypair: usage: mceliece348864pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece348864pcf_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece460896-dec.c0000644000000000000000000000321514441554466017506 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece460896_SECRETKEYBYTES]; static unsigned char c[mceliece460896_CIPHERTEXTBYTES]; static unsigned char k[mceliece460896_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece460896-dec: usage: mceliece460896-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece460896_PUBLICKEYBYTES]; static unsigned char c[mceliece460896_CIPHERTEXTBYTES]; static unsigned char k[mceliece460896_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece460896-enc: usage: mceliece460896-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece460896_PUBLICKEYBYTES]; static unsigned char sk[mceliece460896_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece460896-keypair: usage: mceliece460896-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece460896-keypair: usage: mceliece460896-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece460896_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece460896f-keypair.c0000644000000000000000000000257214441554466020572 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece460896f_PUBLICKEYBYTES]; static unsigned char sk[mceliece460896f_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896f-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896f-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece460896f-keypair: usage: mceliece460896f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece460896f-keypair: usage: mceliece460896f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece460896f_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece460896pc-dec.c0000644000000000000000000000324114441554466020030 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece460896pc_SECRETKEYBYTES]; static unsigned char c[mceliece460896pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece460896pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896pc-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896pc-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece460896pc-dec: usage: mceliece460896pc-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece460896pc_PUBLICKEYBYTES]; static unsigned char c[mceliece460896pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece460896pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896pc-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896pc-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece460896pc-enc: usage: mceliece460896pc-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece460896pc_PUBLICKEYBYTES]; static unsigned char sk[mceliece460896pc_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896pc-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896pc-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece460896pc-keypair: usage: mceliece460896pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece460896pc-keypair: usage: mceliece460896pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece460896pc_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece460896pcf-keypair.c0000644000000000000000000000261414441554466021112 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece460896pcf_PUBLICKEYBYTES]; static unsigned char sk[mceliece460896pcf_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece460896pcf-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece460896pcf-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece460896pcf-keypair: usage: mceliece460896pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece460896pcf-keypair: usage: mceliece460896pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece460896pcf_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6688128-dec.c0000644000000000000000000000322714441554466017577 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece6688128_SECRETKEYBYTES]; static unsigned char c[mceliece6688128_CIPHERTEXTBYTES]; static unsigned char k[mceliece6688128_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece6688128-dec: usage: mceliece6688128-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6688128_PUBLICKEYBYTES]; static unsigned char c[mceliece6688128_CIPHERTEXTBYTES]; static unsigned char k[mceliece6688128_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece6688128-enc: usage: mceliece6688128-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6688128_PUBLICKEYBYTES]; static unsigned char sk[mceliece6688128_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6688128-keypair: usage: mceliece6688128-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6688128-keypair: usage: mceliece6688128-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6688128_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6688128f-keypair.c0000644000000000000000000000260314441554466020653 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6688128f_PUBLICKEYBYTES]; static unsigned char sk[mceliece6688128f_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128f-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128f-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6688128f-keypair: usage: mceliece6688128f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6688128f-keypair: usage: mceliece6688128f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6688128f_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6688128pc-dec.c0000644000000000000000000000325314441554466020121 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece6688128pc_SECRETKEYBYTES]; static unsigned char c[mceliece6688128pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece6688128pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128pc-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128pc-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece6688128pc-dec: usage: mceliece6688128pc-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6688128pc_PUBLICKEYBYTES]; static unsigned char c[mceliece6688128pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece6688128pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128pc-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128pc-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece6688128pc-enc: usage: mceliece6688128pc-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6688128pc_PUBLICKEYBYTES]; static unsigned char sk[mceliece6688128pc_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128pc-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128pc-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6688128pc-keypair: usage: mceliece6688128pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6688128pc-keypair: usage: mceliece6688128pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6688128pc_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6688128pcf-keypair.c0000644000000000000000000000262514441554466021202 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6688128pcf_PUBLICKEYBYTES]; static unsigned char sk[mceliece6688128pcf_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6688128pcf-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6688128pcf-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6688128pcf-keypair: usage: mceliece6688128pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6688128pcf-keypair: usage: mceliece6688128pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6688128pcf_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6960119-dec.c0000644000000000000000000000322714441554466017570 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece6960119_SECRETKEYBYTES]; static unsigned char c[mceliece6960119_CIPHERTEXTBYTES]; static unsigned char k[mceliece6960119_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece6960119-dec: usage: mceliece6960119-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6960119_PUBLICKEYBYTES]; static unsigned char c[mceliece6960119_CIPHERTEXTBYTES]; static unsigned char k[mceliece6960119_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece6960119-enc: usage: mceliece6960119-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6960119_PUBLICKEYBYTES]; static unsigned char sk[mceliece6960119_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6960119-keypair: usage: mceliece6960119-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6960119-keypair: usage: mceliece6960119-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6960119_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6960119f-keypair.c0000644000000000000000000000260314441554466020644 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6960119f_PUBLICKEYBYTES]; static unsigned char sk[mceliece6960119f_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119f-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119f-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6960119f-keypair: usage: mceliece6960119f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6960119f-keypair: usage: mceliece6960119f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6960119f_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6960119pc-dec.c0000644000000000000000000000325314441554466020112 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece6960119pc_SECRETKEYBYTES]; static unsigned char c[mceliece6960119pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece6960119pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119pc-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119pc-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece6960119pc-dec: usage: mceliece6960119pc-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6960119pc_PUBLICKEYBYTES]; static unsigned char c[mceliece6960119pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece6960119pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119pc-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119pc-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece6960119pc-enc: usage: mceliece6960119pc-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6960119pc_PUBLICKEYBYTES]; static unsigned char sk[mceliece6960119pc_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119pc-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119pc-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6960119pc-keypair: usage: mceliece6960119pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6960119pc-keypair: usage: mceliece6960119pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6960119pc_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece6960119pcf-keypair.c0000644000000000000000000000262514441554466021173 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece6960119pcf_PUBLICKEYBYTES]; static unsigned char sk[mceliece6960119pcf_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece6960119pcf-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece6960119pcf-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece6960119pcf-keypair: usage: mceliece6960119pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece6960119pcf-keypair: usage: mceliece6960119pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece6960119pcf_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece8192128-dec.c0000644000000000000000000000322714441554466017567 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece8192128_SECRETKEYBYTES]; static unsigned char c[mceliece8192128_CIPHERTEXTBYTES]; static unsigned char k[mceliece8192128_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece8192128-dec: usage: mceliece8192128-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece8192128_PUBLICKEYBYTES]; static unsigned char c[mceliece8192128_CIPHERTEXTBYTES]; static unsigned char k[mceliece8192128_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece8192128-enc: usage: mceliece8192128-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece8192128_PUBLICKEYBYTES]; static unsigned char sk[mceliece8192128_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece8192128-keypair: usage: mceliece8192128-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece8192128-keypair: usage: mceliece8192128-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece8192128_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece8192128f-keypair.c0000644000000000000000000000260314441554466020643 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece8192128f_PUBLICKEYBYTES]; static unsigned char sk[mceliece8192128f_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128f-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128f-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece8192128f-keypair: usage: mceliece8192128f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece8192128f-keypair: usage: mceliece8192128f-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece8192128f_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece8192128pc-dec.c0000644000000000000000000000325314441554466020111 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char sk[mceliece8192128pc_SECRETKEYBYTES]; static unsigned char c[mceliece8192128pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece8192128pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128pc-dec: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128pc-dec: fatal: %s\n",why); exit(111); } int main() { FILE *skfile; FILE *kfile; limits(); skfile = fdopen(8,"r"); if (!skfile) { fprintf(stderr,"mceliece8192128pc-dec: usage: mceliece8192128pc-dec 7>sessionkey sessionkey #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece8192128pc_PUBLICKEYBYTES]; static unsigned char c[mceliece8192128pc_CIPHERTEXTBYTES]; static unsigned char k[mceliece8192128pc_BYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128pc-enc: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128pc-enc: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *kfile; limits(); pkfile = fdopen(4,"r"); if (!pkfile) { fprintf(stderr,"mceliece8192128pc-enc: usage: mceliece8192128pc-enc >ciphertext 7>sessionkey 4ciphertext 7>sessionkey 4 #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece8192128pc_PUBLICKEYBYTES]; static unsigned char sk[mceliece8192128pc_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128pc-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128pc-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece8192128pc-keypair: usage: mceliece8192128pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece8192128pc-keypair: usage: mceliece8192128pc-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece8192128pc_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/mceliece8192128pcf-keypair.c0000644000000000000000000000262514441554466021172 0ustar rootroot#include #include #include #include #include "mceliece.h" /* -lmceliece */ #include "limits.inc" static unsigned char pk[mceliece8192128pcf_PUBLICKEYBYTES]; static unsigned char sk[mceliece8192128pcf_SECRETKEYBYTES]; static void die_temp(const char *why,const char *why2) { if (why2) fprintf(stderr,"mceliece8192128pcf-keypair: fatal: %s: %s\n",why,why2); else fprintf(stderr,"mceliece8192128pcf-keypair: fatal: %s\n",why); exit(111); } int main() { FILE *pkfile; FILE *skfile; limits(); pkfile = fdopen(5,"w"); if (!pkfile) { fprintf(stderr,"mceliece8192128pcf-keypair: usage: mceliece8192128pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 5 failed",strerror(errno)); } skfile = fdopen(9,"w"); if (!skfile) { fprintf(stderr,"mceliece8192128pcf-keypair: usage: mceliece8192128pcf-keypair: 5>publickey 9>secretkey\n"); die_temp("fdopen 9 failed",strerror(errno)); } mceliece8192128pcf_keypair(pk,sk); if (fwrite(pk,1,sizeof pk,pkfile) < sizeof pk) die_temp("write publickey failed",strerror(errno)); if (fflush(pkfile)) die_temp("write publickey failed",strerror(errno)); fclose(pkfile); if (fwrite(sk,1,sizeof sk,skfile) < sizeof sk) die_temp("write secretkey failed",strerror(errno)); if (fflush(skfile)) die_temp("write secretkey failed",strerror(errno)); fclose(skfile); return 0; } libmceliece-20230612/command/print_cpuid.inc0000644000000000000000000000027414441554466017357 0ustar rootrootstatic void print_cpuid(void) { unsigned int cpuid[32]; mceliece_cpuid(cpuid,32); printf("cpuid"); for (long long j = 0;j < 32;++j) printf(" %08x",cpuid[j]); printf("\n"); } libmceliece-20230612/compilers/0000755000000000000000000000000014441554466014720 5ustar rootrootlibmceliece-20230612/compilers/amd64+sse3+ssse3+sse41+popcnt+avx+bmi1+bmi2+avx20000644000000000000000000000043114441554466025032 0ustar rootrootgcc -Wall -fPIC -fwrapv -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mbmi -mbmi2 -mpopcnt -mavx2 -mtune=haswell libmceliece-20230612/compilers/amd64+sse3+ssse3+sse41+popcnt+avx+bmi1+bmi2+avx2.c0000644000000000000000000000306614441554466025262 0ustar rootroot/* gcc has __builtin_cpu_supports("avx2") but implemented it incorrectly until 2018: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85100 as of 2022, many machines still have buggy versions of gcc furthermore, why is checking just for avx2 enough? has intel guaranteed that it will never introduce a cpu with avx2 instructions and without (e.g.) sse4.2? so manually check cpuid and xgetbv here and include all the "lower" instruction sets rather than trying to guess which ones are implied */ #define CPUID(func,leaf,a,b,c,d) \ __asm("cpuid":"=a"(a),"=b"(b),"=c"(c),"=d"(d):"a"(func),"c"(leaf):) #define WANT_1_3 ((1<<23)|(1<<25)|(1<<26)) /* 23=mmx; 25=sse; 26=sse2 */ #define WANT_1_2 ((1<<0)|(1<<9)|(1<<19)|(1<<20)|(1<<23)|(1<<27)|(1<<28)) /* 0=sse3; 9=ssse3; 19=sse41; 20=sse42; 23=popcnt; 27=osxsave; 28=avx */ #define WANT_7_1 ((1<<3)|(1<<5)|(1<<8)) /* 3=bmi1; 5=avx2; 8=bmi2 */ #define WANT_XCR ((1<<1)|(1<<2)) /* 1=xmm; 2=ymm */ int supports(void) { unsigned int cpuidmax,id0,id1,id2; unsigned int familymodelstepping; unsigned int feature0,feature1,feature2,feature3; unsigned int xcrlow,xcrhigh; CPUID(0,0,cpuidmax,id0,id1,id2); if (cpuidmax < 7) return 0; CPUID(1,0,familymodelstepping,feature1,feature2,feature3); if (WANT_1_2 != (WANT_1_2 & feature2)) return 0; if (WANT_1_3 != (WANT_1_3 & feature3)) return 0; CPUID(7,0,feature0,feature1,feature2,feature3); if (WANT_7_1 != (WANT_7_1 & feature1)) return 0; asm(".byte 15;.byte 1;.byte 208":"=a"(xcrlow),"=d"(xcrhigh):"c"(0)); if (WANT_XCR != (WANT_XCR & xcrlow)) return 0; return 1; } libmceliece-20230612/compilers/default0000644000000000000000000000011514441554466016264 0ustar rootrootgcc -Wall -fPIC -fwrapv -O2 clang -Wall -fPIC -fwrapv -Qunused-arguments -O2 libmceliece-20230612/configure0000755000000000000000000010247114441554466014637 0ustar rootroot#!/usr/bin/env python3 import os import shutil import sys import platform import subprocess import tempfile import hashlib import re def sha512(s): h = hashlib.sha512() h.update(s) return h.digest() prefix = '/usr/local' clean = True trim = True def hostsanitize(host): host = host.split('-')[0] host = ''.join(c for c in host if c in '_0123456789abcdefghijklmnopqrstuvwxyz') for prefix,result in ( ('amd64','amd64'), ('x86_64','amd64'), ('x86','x86'), ('i386','x86'), ('i686','x86'), ('arm64','arm64'), ('armv8','arm64'), ('aarch64','arm64'), ('arm','arm32'), ('riscv64','riscv64'), ('riscv','riscv32'), ('mips64','mips64'), ('mips','mips32'), ('ppc64','ppc64'), ('powerpc64','ppc64'), ('powerpc','ppc32'), ('ppc','ppc32'), ('sparc64','sparc64'), ('sparcv9','sparc64'), ('sun4u','sparc64'), ('sparc','sparc32'), ('sun','sparc32'), ): if host.startswith(prefix): return result return host host = hostsanitize(platform.machine()) configurelog = '' def log(x): global configurelog configurelog += x+'\n' print(x) makefile = '' for arg in sys.argv[1:]: if arg.startswith('--prefix='): prefix = arg[9:] continue if arg.startswith('--host='): host = hostsanitize(arg[7:]) continue if arg == '--clean': clean = True continue if arg == '--noclean': clean = False continue if arg == '--trim': trim = True continue if arg == '--notrim': trim = False continue raise ValueError('unrecognized argument %s' % arg) echoargs = './configure' echoargs += ' --prefix=%s' % prefix echoargs += ' --host=%s' % host if clean: echoargs += ' --clean' if not clean: echoargs += ' --noclean' if trim: echoargs += ' --trim' if not trim: echoargs += ' --notrim' log(echoargs) if prefix[0] != '/': raise ValueError('prefix %s is not an absolute path' % prefix) if clean: shutil.rmtree('build/%s' % host,ignore_errors=True) def dirlinksym(dir,source,target): with tempfile.TemporaryDirectory(dir=dir) as t: os.symlink(target,'%s/symlink' % t) os.rename('%s/symlink' % t,'%s/%s' % (dir,source)) os.makedirs('build/%s' % host,exist_ok=True) os.makedirs('build/%s/package/bin' % host,exist_ok=True) os.makedirs('build/%s/package/lib' % host,exist_ok=True) os.makedirs('build/%s/package/include' % host,exist_ok=True) if clean: os.symlink('../..','build/%s/src' % host) def copytree(src,dst,acceptfn=None): # starting with python 3.8 can use shutil.copytree # with dirs_exist_ok=True # but want to support older versions of python too # and want to symlink rather than copying os.makedirs(dst,exist_ok=True) for fn in sorted(os.listdir(src)): srcfn = '%s/%s' % (src,fn) if os.path.isdir(srcfn): dstfn = '%s/%s' % (dst,fn) copytree(srcfn,dstfn) else: if acceptfn is not None: if not acceptfn(fn): continue dirlinksym(dst,fn,'../'*(len(dst.split('/'))-2)+'src/'+srcfn) shutil.copystat(src,dst) def acceptfn_shared(fn): if fn.startswith('shared-'): return True if fn.endswith('.S'): return True if fn.endswith('.h'): return True if fn.endswith('.data'): return True return False def acceptfn_nonshared(fn): if fn.startswith('shared-'): if fn.endswith('.c'): return False return True if not fn.endswith('.S'): return True return False shutil.copy2('api','build/%s/api' % host) copytree('scripts-build','build/%s/scripts' % host) copytree('cpuid','build/%s/cpuid' % host) copytree('priority','build/%s/priority' % host) copytree('include-build','build/%s/include-build' % host) with open('project/namespace') as f: projectnamespace = f.read().strip() with open('project/library') as f: projectlibrary = f.read().strip() # ----- inttypes with open('inttypes/crypto_intN.h') as f: intN = f.read() with open('inttypes/crypto_uintN.h') as f: uintN = f.read() for bits in 8,16,32,64: with open('build/%s/include-build/crypto_int%d.h' % (host,bits),'w') as f: f.write(re.sub('N',str(bits),intN)) with open('build/%s/include-build/crypto_uint%d.h' % (host,bits),'w') as f: f.write(re.sub('N',str(bits),uintN)) # ----- compilers def compilerversion(c): try: p = subprocess.Popen(c.split()+['--version'],stdout=subprocess.PIPE,stderr=subprocess.STDOUT,universal_newlines=True) out,err = p.communicate() assert not err assert not p.returncode return out except: pass compilerversionline = {} compilers = {} for arch in sorted(os.listdir('compilers')): if arch.endswith('.c'): continue if arch == 'default' or arch == host or arch.startswith('%s+' % host): with open('compilers/%s' % arch) as f: for c in f.readlines(): c = c.strip() cv = compilerversion(c) if cv == None: log('skipping %s compiler %s' % (arch,c)) continue if arch not in compilers: compilers[arch] = [] compilers[arch] += [c] cv = (c+'\n'+cv).strip().replace('\n','; ') compilerversionline[arch,c] = cv log('using %s compiler %s' % (arch,cv)) firstcompiler = compilers['default'][0] with open('build/%s/scripts/cdcompile' % host,'w') as f: f.write('#!/bin/sh\n') f.write('\n') f.write('cd "$1"; shift\n') f.write('exec %s "$@"\n' % firstcompiler) os.chmod('build/%s/scripts/cdcompile' % host,0o755) compilerabbrev = {} i = 0 for arch in sorted(compilers): for compiler in compilers[arch]: compilerabbrev[arch,compiler] = 'C%d'%i i += 1 log('abbreviating %s = %s %s' % (compilerabbrev[arch,compiler],arch,compiler)) os.makedirs('build/%s/compilerarch' % host,exist_ok=True) for arch,compiler in compilerabbrev: with open('build/%s/compilerarch/%s' % (host,compilerabbrev[arch,compiler]),'w') as f: f.write('%s\n' % arch) os.makedirs('build/%s/compilerversion' % host,exist_ok=True) for arch,compiler in compilerabbrev: with open('build/%s/compilerversion/%s' % (host,compilerabbrev[arch,compiler]),'w') as f: f.write('%s\n' % compilerversionline[arch,compiler]) # ----- run-time checks for whether host actually supports compiler copytree('compilers','build/%s/compilers' % host) for arch in sorted(compilers): if arch == 'default': continue assert os.path.exists('compilers/%s.c'%arch) arch_csymbol = ''.join(x if x in '0123456789abcdefghijklmnopqrstuvwxyz' else '_' for x in arch) M = '\n' M += 'compilers/%s.o: compilers/%s.c\n' % (arch,arch) M += '\tscripts/compiledefault compilers %s c -Dsupports=%s_supports_%s\n' % (arch,projectnamespace,arch_csymbol) makefile = M + makefile M = '\n' M += 'compilers-all: %s\n' % ' '.join('compilers/%s.o'%arch for arch in sorted(compilers) if arch != 'default') M += '\ttouch compilers-all\n' makefile = M + makefile # ----- crypto operations = [] primitives = {} sizes = {} exports = {} prototypes = {} with open('api') as f: for line in f: line = line.strip() if line.startswith('crypto_'): x = line.split() x = x[0].split('/') assert len(x) == 2 o = x[0].split('_')[1] if o not in operations: operations += [o] p = x[1] if o not in primitives: primitives[o] = [] primitives[o] += [p] continue if line.startswith('#define '): x = line.split(' ') x = x[1].split('_') assert len(x) == 4 assert x[0] == 'crypto' o = x[1] p = x[2] if (o,p) not in sizes: sizes[o,p] = '' sizes[o,p] += line+'\n' continue if line.endswith(');'): fun,args = line[:-2].split('(') rettype,fun = fun.split() fun = fun.split('_') o = fun[1] assert fun[0] == 'crypto' if o not in exports: exports[o] = [] exports[o] += ['_'.join(fun[1:])] if o not in prototypes: prototypes[o] = [] prototypes[o] += [(rettype,fun,args)] with open('doc/hdoc') as f: hfile = f.read() hfile += """ #ifndef %s_h #define %s_h #ifdef __cplusplus extern "C" { #endif """ % (projectnamespace,projectnamespace) with open('hdef') as f: hfile += '\n' hfile += f.read() with open('version') as f: version = f.readlines()[0].strip() def cstring(x): return '"%s"' % x.replace('\\','\\\\').replace('"','\\"').replace('\n','\\n') hfile += '\n' hfile += '#define %s_version %s\n' % (projectnamespace,cstring(version)) hfile += '#define %s_arch %s\n' % (projectnamespace,cstring(host)) hfile += '\n' hfile += 'extern void %s_cpuid(unsigned int *,long long);\n' % projectnamespace for o in operations: for ppos,p in enumerate(primitives[o]): if (o,p) not in sizes: sizes[o,p] = '' if len(sizes[o,p]) > 0: S = re.sub(' crypto_',' %s_'%projectnamespace,sizes[o,p]) if ppos == 0: hfile += '\n' hfile += re.sub('%s_%s_%s_'%(projectnamespace,o,p),'%s_%s_'%(projectnamespace,o),S) hfile += '\n' hfile += S for rettype,fun,args in prototypes[o]: shortfun = '_'.join(fun[1:]) pshortfun = '_'.join([o,p]+fun[2:]) if ppos == 0: hfile += '\n' hfile += '#define %s_%s %s_%s\n' % (projectnamespace,shortfun,projectnamespace,pshortfun) hfile += '#define %s_dispatch_%s %s_dispatch_%s\n' % (projectnamespace,shortfun,projectnamespace,pshortfun) hfile += '\n' hfile += 'extern %s %s_%s(%s);\n' % (rettype,projectnamespace,pshortfun,args) hfile += 'extern %s (*%s_dispatch_%s(long long))(%s);\n' % (rettype,projectnamespace,pshortfun,args) if ppos == 0: hfile += '\n' hfile += '#define %s_%s_implementation %s_%s_%s_implementation\n' % (projectnamespace,o,projectnamespace,o,p) hfile += '#define %s_%s_compiler %s_%s_%s_compiler\n' % (projectnamespace,o,projectnamespace,o,p) hfile += '#define %s_dispatch_%s_implementation %s_dispatch_%s_%s_implementation\n' % (projectnamespace,o,projectnamespace,o,p) hfile += '#define %s_dispatch_%s_compiler %s_dispatch_%s_%s_compiler\n' % (projectnamespace,o,projectnamespace,o,p) hfile += '#define %s_numimpl_%s %s_numimpl_%s_%s\n' % (projectnamespace,o,projectnamespace,o,p) hfile += '\n' hfile += 'extern const char *%s_%s_%s_implementation(void);\n' % (projectnamespace,o,p) hfile += 'extern const char *%s_%s_%s_compiler(void);\n' % (projectnamespace,o,p) hfile += 'extern const char *%s_dispatch_%s_%s_implementation(long long);\n' % (projectnamespace,o,p) hfile += 'extern const char *%s_dispatch_%s_%s_compiler(long long);\n' % (projectnamespace,o,p) hfile += 'extern long long %s_numimpl_%s_%s(void);\n' % (projectnamespace,o,p) hfile += """ #ifdef __cplusplus } #endif #endif """ with open('build/%s/package/include/%s.h' % (host,projectnamespace),'w') as f: f.write(hfile) os.chmod('build/%s/package/include/%s.h' % (host,projectnamespace),0o644) for o in operations: for p in primitives[o]: cryptoh = '' cryptoh += '#ifndef crypto_%s_%s_h\n' % (o,p) cryptoh += '#define crypto_%s_%s_h\n' % (o,p) cryptoh += '\n' for rettype,fun,args in prototypes[o]: pshortfun = '_'.join([o,p]+fun[2:]) cryptoh += '#define crypto_%s %s_%s\n' % (pshortfun,projectnamespace,pshortfun) cryptoh += '\n' cryptoh += sizes[o,p] cryptoh += '\n' for rettype,fun,args in prototypes[o]: pshortfun = '_'.join([o,p]+fun[2:]) cryptoh += 'extern %s crypto_%s(%s);\n' % (rettype,pshortfun,args) cryptoh += '\n' cryptoh += '#endif\n' with open('build/%s/include-build/crypto_%s_%s.h' % (host,o,p),'w') as f: f.write(cryptoh) doth = {} for o in operations: for p in primitives[o]: result = '' result += '#ifndef crypto_%s_h\n' % o result += '#define crypto_%s_h\n' % o result += '\n' for m in exports[o]: result += '#define crypto_%s CRYPTO_NAMESPACE(%s)\n' % (m,m) result += '\n' result += sizes[o,p] result += re.sub('crypto_%s_%s_'%(o,p),'crypto_%s_'%o,sizes[o,p]) result += '\n' for rettype,fun,args in prototypes[o]: result += 'extern %s %s(%s) __attribute__((visibility("default")));\n' % (rettype,'_'.join(fun),args) result += '\n' result += '#endif\n' doth[o,p] = result impls = {} for o in operations: for p in primitives[o]: impls[o,p] = [] for i in sorted(os.listdir('crypto_%s/%s' % (o,p))): impldir = 'crypto_%s/%s/%s' % (o,p,i) if not os.path.isdir(impldir): continue if os.stat(impldir).st_mode & 0o1000 == 0o1000: log('skipping sticky %s' % impldir) continue implarch = None if os.path.exists('%s/architectures' % impldir): with open('%s/architectures' % impldir) as f: for line in f: line = line.strip().split() if len(line) == 0: continue if line[0] != host: continue implarch = line else: implarch = [host] if implarch == None: continue assert implarch[0] == host impls[o,p] += [(i,impldir,implarch)] undisciplined = set() file_hash = {} inclusions = {} namespace_defines = {} namespace_uses = {} namespace_definedin = {} def file_process(dir,fn,substitutes={}): if (dir,fn) in file_hash: return if fn in substitutes: x = substitutes[fn] else: with open(dir+'/'+fn) as f: x = f.read() file_hash[dir,fn] = sha512(x.encode('utf8')) inclusions[dir,fn] = [] namespace_defines[dir,fn] = [] namespace_uses[dir,fn] = [] for line in x.splitlines(): line = line.split() if line[:3] == ['//','linker','define']: for x in line[3:]: namespace_defines[dir,fn] += [x] if (dir,x) in namespace_definedin: undisciplined.add(dir) namespace_definedin[dir,x] = fn if line[:3] == ['//','linker','use']: for x in line[3:]: namespace_uses[dir,fn] += [x] if line[:1] != ['#include']: continue if len(line) < 2: continue subfn = line[1] if not subfn.startswith('"'): continue if not subfn.endswith('"'): continue subfn = subfn[1:-1] if subfn == 'randombytes.h': continue if subfn.startswith('crypto_') and subfn not in substitutes: continue inclusions[dir,fn] += [subfn] file_process(dir,subfn,substitutes) checksum_cache = {} checksum_inprogress = set() def checksum(dir,fn): if dir in undisciplined: return os.urandom(32) if (dir,fn) not in checksum_cache: if (dir,fn) in checksum_inprogress: undisciplined.add(dir) return os.urandom(32) checksum_inprogress.add((dir,fn)) result = file_hash[dir,fn] for subfn in inclusions[dir,fn]: result += checksum(dir,subfn) for symbol in namespace_uses[dir,fn]: if (dir,symbol) in namespace_definedin: result += checksum(dir,namespace_definedin[dir,symbol]) result = sha512(result) checksum_cache[dir,fn] = result checksum_inprogress.remove((dir,fn)) return checksum_cache[dir,fn] checksum_context = {} for o in operations: for p in primitives[o]: for i,impldir,implarch in impls[o,p]: for fn in sorted(os.listdir(impldir)): if fn.endswith('.c') or fn.endswith('.S'): file_process(impldir,fn,substitutes={'crypto_%s.h'%o:doth[o,p]}) for fn in sorted(os.listdir(impldir)): if fn.endswith('.c') or fn.endswith('.S'): c = checksum(impldir,fn) if c not in checksum_context: checksum_context[c] = [] checksum_context[c] += [(o,p,i,impldir,implarch,fn)] copywithinclusions_done = set() def copywithinclusions(targetdir,dir,fn,substitutes={}): if (targetdir,fn) in copywithinclusions_done: return copywithinclusions_done.add((targetdir,fn)) if fn in substitutes: with open(targetdir+'/'+fn,'w') as f: f.write(substitutes[fn]) shutil.copystat(dir,targetdir+'/'+fn) else: dirlinksym(targetdir,fn,'../'*(len(targetdir.split('/'))-2)+'src/'+dir+'/'+fn) for subfn in inclusions[dir,fn]: copywithinclusions(targetdir,dir,subfn,substitutes) unified_files = {} # crypto_o/p/i/fn will be unified across multiple (o,p,i,fn) # if fn in unified_files[o,p,i] for o in operations: for p in primitives[o]: for i,impldir,implarch in impls[o,p]: unified_files[o,p,i] = set() unified_symbols = set() for fn in sorted(os.listdir(impldir)): if not(fn.endswith('.S') or fn.endswith('.c')): continue if len(namespace_defines[impldir,fn]) == 0: continue c = checksum(impldir,fn) if c not in checksum_context: continue if len(checksum_context[c]) == 1: continue unified_files[o,p,i].add(fn) for symbol in namespace_defines[impldir,fn]: unified_symbols.add(symbol) progress = True while progress: progress = False for fn in sorted(unified_files[o,p,i]): if any(symbol not in unified_symbols for symbol in namespace_uses[impldir,fn]): progress = True unified_files[o,p,i].remove(fn) for symbol in namespace_defines[impldir,fn]: unified_symbols.remove(symbol) unified_built = set() checksum_unified = {} unified_counter = {} def unified_dir(o,p,i,fn): allowedchars = '0123456789' allowedchars += 'abcdefghijklmnopqrstuvwxyz' allowedchars += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' base = ''.join(c for c in fn if c in allowedchars) if len(base) == 0: base = 'x' if base not in unified_counter: unified_counter[base] = 0 unified_counter[base] += 1 return 'unified/%s/%d' % (base,unified_counter[base]) for o in operations: for p in primitives[o]: for i,impldir,implarch in impls[o,p]: if impldir in undisciplined: log('warning: undisciplined %s' % impldir) unified_files[o,p,i] = [] for fn in unified_files[o,p,i]: if acceptfn_shared(fn): c = checksum(impldir,fn) if c not in checksum_unified: checksum_unified[c] = unified_dir(o,p,i,fn) else: for arch in compilers: if any(implarchreq not in arch.split('+')[1:] for implarchreq in implarch[1:]): continue for compiler in compilers[arch]: c = checksum(impldir,fn) if (c,compiler) not in checksum_unified: checksum_unified[c,compiler] = unified_dir(o,p,i,fn) ofiles = [] opicdirs = [] builddirs = [] opicdir2dependencies = {} def impl2symbol(i): return i.replace('-','').replace('_','') for o in operations: for p in primitives[o]: for i,impldir,implarch in impls[o,p]: builtshared = False needshared = False shareddeps = [] for arch in compilers: if any(implarchreq not in arch.split('+')[1:] for implarchreq in implarch[1:]): continue for compiler in compilers[arch]: if not builtshared: shareddeps += ['%s/%s/%s/shared' % (o,p,i)] builddirs += ['%s/%s/%s/shared' % (o,p,i)] shared_builddir = 'build/%s/%s/%s/%s/shared' % (host,o,p,i) os.makedirs(shared_builddir,exist_ok=True) copytree(impldir,shared_builddir,acceptfn_shared) nonunified_shared_compiler = compiler for fn2 in sorted(unified_files[o,p,i]): if not acceptfn_shared(fn2): continue for symbol in namespace_defines[impldir,fn2]: c2 = checksum(impldir,fn2) nonunified_shared_compiler += ' -D%s_%s_%s_%s_%s_%s=%s_%s_%s_%s' % ( projectnamespace,o,p,impl2symbol(i),'shared',symbol, projectnamespace,checksum_unified[c2].replace('/','_'),'shared',symbol ) with open('%s/compiler' % shared_builddir,'w') as f: f.write(nonunified_shared_compiler+'\n') for fn in sorted(os.listdir(impldir)): if not acceptfn_shared(fn): continue if fn.endswith('.S') or fn.endswith('.c'): needshared = True base = fn[:-2] ext = fn[-1:] if fn in unified_files[o,p,i]: if not acceptfn_shared(fn): continue c = checksum(impldir,fn) shareddeps += ['%s/shared' % checksum_unified[c]] if checksum_unified[c] not in unified_built: builddirs += ['%s/shared' % checksum_unified[c]] unifieddir = 'build/%s/%s/shared' % (host,checksum_unified[c]) os.makedirs(unifieddir,exist_ok=True) copywithinclusions(unifieddir,impldir,fn,substitutes={'crypto_%s.h'%o:doth[o,p]}) unified_shared_compiler = compiler for fn2 in sorted(unified_files[o,p,i]): if not acceptfn_shared(fn2): continue for symbol in namespace_defines[impldir,fn2]: c2 = checksum(impldir,fn2) unified_shared_compiler += ' -D%s_%s_%s_%s=%s_%s_%s_%s' % ( projectnamespace,checksum_unified[c].replace('/','_'),'shared',symbol, projectnamespace,checksum_unified[c2].replace('/','_'),'shared',symbol ) with open('%s/compiler' % unifieddir,'w') as f: f.write(unified_shared_compiler+'\n') makefile += '\n' ofiles += ['%s/shared/%s.o' % (checksum_unified[c],base)] makefile += '%s/shared/%s.o: %s/shared/%s\n' % (checksum_unified[c],base,checksum_unified[c],fn) makefile += '\tscripts/compile %s/shared %s %s\n' % (checksum_unified[c],base,ext) unified_built.add(checksum_unified[c]) else: makefile += '\n' ofiles += ['%s/%s/%s/shared/%s.o' % (o,p,i,base)] makefile += '%s/%s/%s/shared/%s.o: %s/%s/%s/shared/%s\n' % (o,p,i,base,o,p,i,fn) makefile += '\tscripts/compile %s/%s/%s/shared %s %s\n' % (o,p,i,base,ext) builtshared = True dependencies = list(shareddeps) if needshared else [] compilerdir = compilerabbrev[arch,compiler] opicdir = '%s/%s/%s/%s' % (o,p,i,compilerdir) opicdirs += [opicdir] builddirs += [opicdir] builddir = 'build/%s/%s/%s/%s/%s' % (host,o,p,i,compilerdir) os.makedirs(builddir,exist_ok=True) copytree(impldir,builddir,acceptfn_nonshared) nonunified_nonshared_compiler = compiler for fn in sorted(unified_files[o,p,i]): for symbol in namespace_defines[impldir,fn]: c = checksum(impldir,fn) if acceptfn_shared(fn): nonunified_nonshared_compiler += ' -D%s_%s_%s_%s_%s_%s=%s_%s_%s_%s' % ( projectnamespace,o,p,impl2symbol(i),'shared',symbol, projectnamespace,checksum_unified[c].replace('/','_'),'shared',symbol ) else: nonunified_nonshared_compiler += ' -D%s_%s_%s_%s_%s_%s=%s_%s_%s_%s' % ( projectnamespace,o,p,impl2symbol(i),compilerdir,symbol, projectnamespace,checksum_unified[c,compiler].replace('/','_'),compilerdir,symbol ) with open('%s/crypto_%s.h' % (builddir,o),'w') as f: f.write(doth[o,p]) with open('%s/compiler' % builddir,'w') as f: f.write(nonunified_nonshared_compiler+'\n') for fn in sorted(os.listdir(impldir)): if not acceptfn_nonshared(fn): continue if fn.endswith('.c'): base = fn[:-2] ext = fn[-1:] if fn in unified_files[o,p,i]: if not acceptfn_nonshared(fn): continue c = checksum(impldir,fn) dependencies += ['%s/%s' % (checksum_unified[c,compiler],compilerdir)] if checksum_unified[c,compiler] not in unified_built: unifieddir = 'build/%s/%s/%s' % (host,checksum_unified[c,compiler],compilerdir) builddirs += ['%s/%s' % (checksum_unified[c,compiler],compilerdir)] os.makedirs(unifieddir,exist_ok=True) copywithinclusions(unifieddir,impldir,fn,substitutes={'crypto_%s.h'%o:doth[o,p]}) unified_nonshared_compiler = compiler for fn2 in sorted(unified_files[o,p,i]): for symbol in namespace_defines[impldir,fn2]: c2 = checksum(impldir,fn2) if acceptfn_shared(fn2): unified_nonshared_compiler += ' -D%s_%s_%s_%s=%s_%s_%s_%s' % ( projectnamespace,checksum_unified[c,compiler].replace('/','_'),'shared',symbol, projectnamespace,checksum_unified[c2].replace('/','_'),'shared',symbol ) else: unified_nonshared_compiler += ' -D%s_%s_%s_%s=%s_%s_%s_%s' % ( projectnamespace,checksum_unified[c,compiler].replace('/','_'),compilerdir,symbol, projectnamespace,checksum_unified[c2,compiler].replace('/','_'),compilerdir,symbol ) with open('%s/compiler' % unifieddir,'w') as f: f.write(unified_nonshared_compiler+'\n') makefile += '\n' ofiles += ['%s/%s/%s.o' % (checksum_unified[c,compiler],compilerdir,base)] makefile += '%s/%s/%s.o: %s/%s/%s\n' % (checksum_unified[c,compiler],compilerdir,base,checksum_unified[c,compiler],compilerdir,fn) makefile += '\tscripts/compile %s/%s %s %s\n' % (checksum_unified[c,compiler],compilerdir,base,ext) unified_built.add(checksum_unified[c,compiler]) else: makefile += '\n' ofiles += ['%s/%s/%s/%s/%s.o' % (o,p,i,compilerdir,base)] makefile += '%s/%s/%s/%s/%s.o: %s/%s/%s/%s/%s\n' % (o,p,i,compilerdir,base,o,p,i,compilerdir,fn) makefile += '\tscripts/compile %s/%s/%s/%s %s %s\n' % (o,p,i,compilerdir,base,ext) opicdir2dependencies[opicdir] = dependencies if len(dependencies) > 0: with open(builddir+'/dependencies','w') as f: f.write('\n'.join(dependencies)) # ----- dispatch with open('build/%s/opicdirs'%host,'w') as f: for opicdir in opicdirs: f.write(opicdir+'\n') M = '' M += 'compiledimplementations: opicdirs scripts/compiledimplementations result-impl \\\n' for opicdir in opicdirs: M += '%s/allcompiled \\\n' % opicdir M += '\n' M += '\tscripts/compiledimplementations < opicdirs > compiledimplementations\n' M += '\tcat result-impl\n' M += '\n' M += 'result-impl: \\\n' for opicdir in opicdirs: M += '%s/result \\\n' % opicdir M += '\n' M += '\tscripts/result-impl < opicdirs > result-impl\n' M += '\n' for opicdir in opicdirs: if len(opicdir2dependencies[opicdir]) > 0: dependencies_compiled = ' '.join(builddir+'/allcompiled' for builddir in opicdir2dependencies[opicdir]) M += '%s/allcompiled: %s\n' % (opicdir,dependencies_compiled) M += '\n' builddir_ofiles = {} for builddir in builddirs: assert len(builddir.split('/')) == 4 builddir_ofiles[builddir] = [] for ofile in ofiles: builddir = ofile.split('/')[:4] if len(builddir) < 4: continue builddir = '/'.join(builddir) builddir_ofiles[builddir] += [ofile] for builddir in builddirs: M += '%s/allcompiled: %s\n' % (builddir,' '.join(builddir_ofiles[builddir])) M += '\ttouch %s/allcompiled\n' % builddir M += '\n' for opicdir in opicdirs: deps = [opicdir+'/result-namespace',opicdir+'/result-insns'] deps += builddir_ofiles[opicdir] deps = ' '.join(deps) results = [opicdir+'/result-namespace',opicdir+'/result-insns'] for ofile in builddir_ofiles[opicdir]: ofile = '/'.join(ofile.split('/')[4:]) results += [opicdir+'/result-compile-'+ofile[:-2]] results = ' '.join(results) M += '%s/result: %s\n' % (opicdir,deps) M += '\tcat %s > %s/result\n' % (results,opicdir) M += '\n' for opicdir in opicdirs: M += '%s/result-insns: %s/allcompiled scripts/checkinsns\n' % (opicdir,opicdir) M += '\tscripts/checkinsns %s %s\n' % (host,opicdir) M += '\n' for opicdir in opicdirs: M += '%s/result-namespace: %s/allcompiled scripts/checknamespace\n' % (opicdir,opicdir) M += '\tscripts/checknamespace %s %s\n' % (projectnamespace,opicdir) M += '\n' makefile = M + makefile selectedlist = ' '.join('selected/%s_%s' % (o,p) for o in operations for p in primitives[o]) M = 'usedimplementations: scripts/usedimplementations %s\n' % selectedlist M += '\tscripts/usedimplementations %s > usedimplementations\n' % selectedlist M += '\n' makefile = M + makefile os.makedirs('build/%s/selected' % host,exist_ok=True) M = '' for o in operations: for p in primitives[o]: M += 'selected/%s_%s: scripts/selected compiledimplementations\n' % (o,p) M += '\tscripts/selected %s %s %s %s < compiledimplementations > selected/%s_%s\n' % (o,p,host,trim,o,p) M += '\n' makefile = M + makefile for goal in 'auto','manual': os.makedirs('build/%s/dispatch-%s' % (host,goal),exist_ok=True) M = '' for o in operations: for p in primitives[o]: M += 'dispatch-%s/%s_%s.c: scripts/dispatch selected/%s_%s\n' % (goal,o,p,o,p) M += '\tscripts/dispatch %s %s %s %s < selected/%s_%s > dispatch-%s/%s_%s.c\n' % (goal,o,p,host,o,p,goal,o,p) M += '\n' makefile = M + makefile M = '' for o in operations: for p in primitives[o]: M += 'dispatch-%s/%s_%s.o: dispatch-%s/%s_%s.c\n' % (goal,o,p,goal,o,p) M += '\tscripts/compiledefault dispatch-%s %s_%s c\n' % (goal,o,p) M += '\n' makefile = M + makefile M = 'dispatch-%s-all: \\\n' % goal for o in operations: for p in primitives[o]: M += 'dispatch-%s/%s_%s.o \\\n' % (goal,o,p) M += '\n' M += '\ttouch dispatch-%s-all\n' % goal M += '\n' makefile = M + makefile # ----- projectlibrary M = 'odirs: usedimplementations\n' M += '\t( cat usedimplementations; echo dispatch-auto; echo dispatch-manual; echo compilers; echo cpuid ) > odirs\n' M += '\n' makefile = M + makefile M = 'ofiles: scripts/ofiles odirs usedimplementations dispatch-auto-all dispatch-manual-all compilers-all cpuid-all\n' M += '\tscripts/ofiles < odirs\n' M += '\n' makefile = M + makefile M = 'package/lib/lib%s.a: scripts/staticlib ofiles\n' % projectlibrary M += '\tscripts/staticlib lib%s\n' % projectlibrary M += '\n' makefile = M + makefile M = 'package/lib/lib%s.so.1: scripts/sharedlib ofiles\n' % projectlibrary M += '\tscripts/sharedlib lib%s -lrandombytes\n' % projectlibrary M += '\n' makefile = M + makefile M = 'package/lib/lib%s.so: package/lib/lib%s.so.1\n' % (projectlibrary,projectlibrary) M += '\trm -f package/lib/lib%s.so\n' % projectlibrary M += '\tln -s lib%s.so.1 package/lib/lib%s.so\n' % (projectlibrary,projectlibrary) M += '\n' makefile = M + makefile # ----- cpuid cpuid = host if not os.path.exists('cpuid/%s.c' % host): cpuid = 'default' M = '\n' M += 'cpuid-all: cpuid/%s.o\n' % cpuid M += '\ttouch cpuid-all\n' M += '\n' M += 'cpuid/%s.o: cpuid/%s.c\n' % (cpuid,cpuid) M += '\tscripts/compiledefault cpuid %s c\n' % cpuid makefile += M # ----- command copytree('command','build/%s/command'%host) dirlinksym('build/%s/command'%host,'bin','../package/bin') dirlinksym('build/%s/command'%host,'lib','../package/lib') dirlinksym('build/%s/command'%host,'include-build','../include-build') dirlinksym('build/%s/command'%host,'include','../package/include') with open('build/%s/command/link' % host,'w') as f: f.write('#!/bin/sh\n') f.write('target="$1"; shift\n') f.write('%s \\\n' % firstcompiler) f.write(' -fvisibility=hidden \\\n') f.write(' -o "$target" "$@"\n') os.chmod('build/%s/command/link' % host,0o755) commands = [] for fn in sorted(os.listdir('command')): if not fn.endswith('.c'): continue base = fn[:-2] deps = 'command/%s.o'%base link = 'cd command && ./link bin/%s %s.o'%(base,base) syslink = '' with open('command/%s' % fn) as f: for line in f: line = line.strip().split() if len(line) < 1: continue if line[0] != '#include': continue if '-lcpucycles' in line: syslink += ' -lcpucycles' if '-lrandombytes' in line: syslink += ' -lrandombytes' if '-l%s'%projectlibrary in line: deps += ' package/lib/lib%s.so' % projectlibrary link += ' lib/lib%s.so' % projectlibrary link += syslink M = 'command/%s.o: command/%s.c\n' % (base,base) M += '\tscripts/compiledefault command %s c -I include -I include-build\n' % base M += '\n' makefile = M + makefile M = 'package/bin/%s: %s\n' % (base,deps) M += '\t%s\n' % link M += '\n' makefile = M + makefile commands += ['package/bin/%s' % base] M = 'commands: %s\n' % ' '.join(commands) M += '\n' makefile = M + makefile # ----- manual pages for manpage in sorted(os.listdir('doc/man')): section = 'man%s' % manpage[-1] targetdir = 'build/%s/package/man/%s' % (host,section) os.makedirs(targetdir,exist_ok=True) shutil.copy2('doc/man/%s'%manpage,'%s/%s'%(targetdir,manpage)) # ----- make install M = 'install: scripts/install default\n' M += '\tscripts/install %s\n' % prefix M += '\n' makefile = M + makefile # ----- make default M = 'default: package/lib/lib%s.a package/lib/lib%s.so package/lib/lib%s.so.1 \\\n' % (projectlibrary,projectlibrary,projectlibrary) M += 'commands\n' M += '\n' makefile = M + makefile with open('build/%s/Makefile' % host,'w') as f: f.write(makefile) # ----- build/0, build/Makefile dirlinksym('build','0',host) with open('build/Makefile','w') as f: f.write('default:\n') f.write('\tcd %s && $(MAKE)\n' % host) f.write('\n') f.write('install:\n') f.write('\tcd %s && $(MAKE) install\n' % host) f.write('\n') f.write('clean:\n') f.write('\trm -r %s\n' % host) log('configure done') with open('build/%s/configure.log'%host,'a') as f: f.write(configurelog) with open('build/%s/configure.log.latest'%host,'w') as f: f.write(configurelog) libmceliece-20230612/cpuid/0000755000000000000000000000000014441554466014027 5ustar rootrootlibmceliece-20230612/cpuid/amd64.c0000644000000000000000000000513714441554466015114 0ustar rootroot#include #define CPUID(func,leaf,a,b,c,d) \ __asm("cpuid":"=a"(a),"=b"(b),"=c"(c),"=d"(d):"a"(func),"c"(leaf):) __attribute__((visibility("default"))) void mceliece_cpuid(unsigned int *result,long long resultlen) { unsigned int a,b,c,d; unsigned int cpuidmax,extendedcpuidmax; int havexgetbv = 0; CPUID(0,0,a,b,c,d); cpuidmax = a; if (resultlen > 0) { *result++ = b; --resultlen; } if (resultlen > 0) { *result++ = c; --resultlen; } if (resultlen > 0) { *result++ = d; --resultlen; } a = b = c = d = 0; CPUID(0x80000000,0,a,b,c,d); extendedcpuidmax = a; a = b = c = d = 0; if (extendedcpuidmax >= 0x80000002) CPUID(0x80000002,0,a,b,c,d); if (resultlen > 0) { *result++ = a; --resultlen; } if (resultlen > 0) { *result++ = b; --resultlen; } if (resultlen > 0) { *result++ = c; --resultlen; } if (resultlen > 0) { *result++ = d; --resultlen; } a = b = c = d = 0; if (extendedcpuidmax >= 0x80000003) CPUID(0x80000003,0,a,b,c,d); if (resultlen > 0) { *result++ = a; --resultlen; } if (resultlen > 0) { *result++ = b; --resultlen; } if (resultlen > 0) { *result++ = c; --resultlen; } if (resultlen > 0) { *result++ = d; --resultlen; } a = b = c = d = 0; if (extendedcpuidmax >= 0x80000004) CPUID(0x80000004,0,a,b,c,d); if (resultlen > 0) { *result++ = a; --resultlen; } if (resultlen > 0) { *result++ = b; --resultlen; } if (resultlen > 0) { *result++ = c; --resultlen; } if (resultlen > 0) { *result++ = d; --resultlen; } a = b = c = d = 0; if (cpuidmax >= 1) CPUID(1,0,a,b,c,d); if (resultlen > 0) { *result++ = a; --resultlen; } if (resultlen > 0) { *result++ = b; --resultlen; } if (resultlen > 0) { *result++ = c; --resultlen; } if (resultlen > 0) { *result++ = d; --resultlen; } /* 27=osxsave; 28=avx */ if (((1<<27)|(1<<28)) == (((1<<27)|(1<<28)) & c)) havexgetbv = 1; a = b = c = d = 0; if (cpuidmax >= 7) CPUID(7,0,a,b,c,d); if (resultlen > 0) { *result++ = a; --resultlen; } if (resultlen > 0) { *result++ = b; --resultlen; } if (resultlen > 0) { *result++ = c; --resultlen; } if (resultlen > 0) { *result++ = d; --resultlen; } a = b = c = d = 0; if (extendedcpuidmax >= 0x80000001) CPUID(0x80000001,0,a,b,c,d); if (resultlen > 0) { *result++ = a; --resultlen; } if (resultlen > 0) { *result++ = b; --resultlen; } if (resultlen > 0) { *result++ = c; --resultlen; } if (resultlen > 0) { *result++ = d; --resultlen; } a = b = c = d = 0; if (havexgetbv) asm(".byte 15;.byte 1;.byte 208":"=a"(a),"=d"(d):"c"(0)); if (resultlen > 0) { *result++ = a; --resultlen; } while (resultlen > 0) { *result++ = 0; --resultlen; } } libmceliece-20230612/cpuid/default.c0000644000000000000000000000026514441554466015622 0ustar rootroot#include __attribute__((visibility("default"))) void mceliece_cpuid(unsigned int *result,long long resultlen) { while (resultlen > 0) { *result++ = 0; --resultlen; } } libmceliece-20230612/crypto_kem/0000755000000000000000000000000014441554506015072 5ustar rootrootlibmceliece-20230612/crypto_kem/348864/0000755000000000000000000000000014441554467015660 5ustar rootrootlibmceliece-20230612/crypto_kem/348864/avx/0000755000000000000000000000000014441554467016456 5ustar rootrootlibmceliece-20230612/crypto_kem/348864/avx/architectures0000644000000000000000000000006114441554466021242 0ustar rootrootamd64 sse3 ssse3 sse41 popcnt avx bmi1 bmi2 avx2 libmceliece-20230612/crypto_kem/348864/avx/benes.c0000644000000000000000000001270014441554466017715 0ustar rootroot/* This file is for Benes network related functions For the implementation strategy, see https://eprint.iacr.org/2017/793.pdf */ // 20221231 djb: remove unused counter increment; tnx thom wiggers // 20221230 djb: add linker lines // linker define load_bits benes // linker use transpose_64x64_asm #include "util.h" #include "transpose.h" #include "params.h" #include "benes.h" static void layer_0(uint64_t *bs, uint64_t *cond) { int x; uint64_t diff; for (x = 0; x < (1 << 6); x += 2) { diff = bs[ x ] ^ bs[ x+1 ]; diff &= *cond++; bs[ x ] ^= diff; bs[ x+1 ] ^= diff; } } static void layer_1(uint64_t *bs, uint64_t *cond) { int x; uint64_t diff; for (x = 0; x < (1 << 6); x += 4) { diff = bs[ x+0 ] ^ bs[ x+2 ]; diff &= cond[0]; bs[ x+0 ] ^= diff; bs[ x+2 ] ^= diff; diff = bs[ x+1 ] ^ bs[ x+3 ]; diff &= cond[1]; bs[ x+1 ] ^= diff; bs[ x+3 ] ^= diff; cond += 2; } } static void layer_2(uint64_t *bs, uint64_t *cond) { int x; uint64_t diff; for (x = 0; x < (1 << 6); x += 8) { diff = bs[ x+0 ] ^ bs[ x+4 ]; diff &= cond[0]; bs[ x+0 ] ^= diff; bs[ x+4 ] ^= diff; diff = bs[ x+1 ] ^ bs[ x+5 ]; diff &= cond[1]; bs[ x+1 ] ^= diff; bs[ x+5 ] ^= diff; diff = bs[ x+2 ] ^ bs[ x+6 ]; diff &= cond[2]; bs[ x+2 ] ^= diff; bs[ x+6 ] ^= diff; diff = bs[ x+3 ] ^ bs[ x+7 ]; diff &= cond[3]; bs[ x+3 ] ^= diff; bs[ x+7 ] ^= diff; cond += 4; } } static void layer_3(uint64_t *bs, uint64_t *cond) { int x, s; uint64_t diff; for (x = 0; x < (1 << 6); x += 16) for (s = x; s < x + 8; s += 4) { diff = bs[ s+0 ] ^ bs[ s+8 ]; diff &= cond[0]; bs[ s+0 ] ^= diff; bs[ s+8 ] ^= diff; diff = bs[ s+1 ] ^ bs[ s+9 ]; diff &= cond[1]; bs[ s+1 ] ^= diff; bs[ s+9 ] ^= diff; diff = bs[ s+2 ] ^ bs[ s+10 ]; diff &= cond[2]; bs[ s+2 ] ^= diff; bs[ s+10 ] ^= diff; diff = bs[ s+3 ] ^ bs[ s+11 ]; diff &= cond[3]; bs[ s+3 ] ^= diff; bs[ s+11 ] ^= diff; cond += 4; } } static void layer_4(uint64_t *bs, uint64_t *cond) { int x, s; uint64_t diff; for (x = 0; x < (1 << 6); x += 32) for (s = x; s < x + 16; s += 4) { diff = bs[ s+0 ] ^ bs[ s+16 ]; diff &= cond[0]; bs[ s+0 ] ^= diff; bs[ s+16 ] ^= diff; diff = bs[ s+1 ] ^ bs[ s+17 ]; diff &= cond[1]; bs[ s+1 ] ^= diff; bs[ s+17 ] ^= diff; diff = bs[ s+2 ] ^ bs[ s+18 ]; diff &= cond[2]; bs[ s+2 ] ^= diff; bs[ s+18 ] ^= diff; diff = bs[ s+3 ] ^ bs[ s+19 ]; diff &= cond[3]; bs[ s+3 ] ^= diff; bs[ s+19 ] ^= diff; cond += 4; } } static void layer_5(uint64_t *bs, uint64_t *cond) { int x, s; uint64_t diff; for (x = 0; x < (1 << 6); x += 64) for (s = x; s < x + 32; s += 4) { diff = bs[ s+0 ] ^ bs[ s+32 ]; diff &= cond[0]; bs[ s+0 ] ^= diff; bs[ s+32 ] ^= diff; diff = bs[ s+1 ] ^ bs[ s+33 ]; diff &= cond[1]; bs[ s+1 ] ^= diff; bs[ s+33 ] ^= diff; diff = bs[ s+2 ] ^ bs[ s+34 ]; diff &= cond[2]; bs[ s+2 ] ^= diff; bs[ s+34 ] ^= diff; diff = bs[ s+3 ] ^ bs[ s+35 ]; diff &= cond[3]; bs[ s+3 ] ^= diff; bs[ s+35 ] ^= diff; cond += 4; } } /* input: bits, control bits as array of bytes */ /* output: out, control bits as array of 64-bit vectors */ void load_bits(uint64_t out[][32], const unsigned char * bits) { int i, low, block = 0; uint64_t cond[64]; // for (low = 0; low <= 5; low++) { for (i = 0; i < 64; i++) cond[i] = load4(bits + block*256 + i*4); transpose_64x64(cond); for (i = 0; i < 32; i++) out[ block ][i] = cond[i]; block++; } for (low = 0; low <= 5; low++) { for (i = 0; i < 32; i++) out[ block ][i] = load8(bits + block*256 + i*8); block++; } for (low = 4; low >= 0; low--) { for (i = 0; i < 32; i++) out[ block ][i] = load8(bits + block*256 + i*8); block++; } for (low = 5; low >= 0; low--) { for (i = 0; i < 64; i++) cond[i] = load4(bits + block*256 + i*4); transpose_64x64(cond); for (i = 0; i < 32; i++) out[ block ][i] = cond[i]; block++; } } /* input: r, sequence of bits to be permuted */ /* cond, control bits as array of 64-bit vectors */ /* rev, 0 for normal application; !0 for inverse */ /* output: r, permuted bits */ void benes(uint64_t * r, uint64_t cond[][32], int rev) { int block, inc; uint64_t *bs = r; // if (rev == 0) {block = 0; inc = 1;} else {block = 22; inc = -1;} transpose_64x64(bs); layer_0(bs, cond[ block ]); block += inc; layer_1(bs, cond[ block ]); block += inc; layer_2(bs, cond[ block ]); block += inc; layer_3(bs, cond[ block ]); block += inc; layer_4(bs, cond[ block ]); block += inc; layer_5(bs, cond[ block ]); block += inc; transpose_64x64(bs); layer_0(bs, cond[ block ]); block += inc; layer_1(bs, cond[ block ]); block += inc; layer_2(bs, cond[ block ]); block += inc; layer_3(bs, cond[ block ]); block += inc; layer_4(bs, cond[ block ]); block += inc; layer_5(bs, cond[ block ]); block += inc; layer_4(bs, cond[ block ]); block += inc; layer_3(bs, cond[ block ]); block += inc; layer_2(bs, cond[ block ]); block += inc; layer_1(bs, cond[ block ]); block += inc; layer_0(bs, cond[ block ]); block += inc; transpose_64x64(bs); layer_5(bs, cond[ block ]); block += inc; layer_4(bs, cond[ block ]); block += inc; layer_3(bs, cond[ block ]); block += inc; layer_2(bs, cond[ block ]); block += inc; layer_1(bs, cond[ block ]); block += inc; layer_0(bs, cond[ block ]); transpose_64x64(bs); } libmceliece-20230612/crypto_kem/348864/avx/benes.h0000644000000000000000000000062014441554466017720 0ustar rootroot/* This file is for Benes network related functions */ #ifndef BENES_H #define BENES_H #define benes CRYPTO_NAMESPACE(benes) #define load_bits CRYPTO_NAMESPACE(load_bits) #define support_gen CRYPTO_NAMESPACE(support_gen) #include "gf.h" void load_bits(uint64_t [][32], const unsigned char *); void benes(uint64_t *, uint64_t [][32], int); void support_gen(gf *, const unsigned char *); #endif libmceliece-20230612/crypto_kem/348864/avx/bm.c0000644000000000000000000001222014441554466017214 0ustar rootroot#define update_asm CRYPTO_SHARED_NAMESPACE(update_asm) #define _update_asm _CRYPTO_SHARED_NAMESPACE(update_asm) #define vec_reduce_asm CRYPTO_SHARED_NAMESPACE(vec_reduce_asm) #define _vec_reduce_asm _CRYPTO_SHARED_NAMESPACE(vec_reduce_asm) /* This file is for implementating the inversion-free Berlekamp-Massey algorithm see https://ieeexplore.ieee.org/document/87857 For the implementation strategy, see https://eprint.iacr.org/2017/793.pdf */ // 20221231 djb: ALIGN(32) for some arrays; tnx thom wiggers // 20221230 djb: add linker lines // linker define bm // linker use update_asm vec_reduce_asm // linker use vec_mul_sp_asm // linker use vec128_mul_asm // linker use gf_inv #include "bm.h" #include "vec128.h" #include "util.h" #include "vec.h" #include "gf.h" #include #include extern void update_asm(void *, gf, int); extern gf vec_reduce_asm(uint64_t *); static inline uint64_t mask_nonzero(gf a) { uint64_t ret = a; ret -= 1; ret >>= 63; ret -= 1; return ret; } static inline uint64_t mask_leq(uint16_t a, uint16_t b) { uint64_t a_tmp = a; uint64_t b_tmp = b; uint64_t ret = b_tmp - a_tmp; ret >>= 63; ret -= 1; return ret; } static inline void vec_cmov(uint64_t out[][2], uint64_t mask) { int i; for (i = 0; i < GFBITS; i++) out[i][0] = (out[i][0] & ~mask) | (out[i][1] & mask); } static inline void interleave(vec128 *in, int idx0, int idx1, vec128 *mask, int b) { int s = 1 << b; vec128 x, y; x = vec128_or(vec128_and(in[idx0], mask[0]), vec128_sll_2x(vec128_and(in[idx1], mask[0]), s)); y = vec128_or(vec128_srl_2x(vec128_and(in[idx0], mask[1]), s), vec128_and(in[idx1], mask[1])); in[idx0] = x; in[idx1] = y; } /* input: in, field elements in bitsliced form */ /* output: out, field elements in non-bitsliced form */ static inline void get_coefs(gf *out, vec128 *in) { int i, k; vec128 mask[4][2]; vec128 buf[16]; for (i = 0; i < GFBITS; i++) buf[i] = in[i]; for (i = GFBITS; i < 16; i++) buf[i] = vec128_setzero(); mask[0][0] = vec128_set1_16b(0x5555); mask[0][1] = vec128_set1_16b(0xAAAA); mask[1][0] = vec128_set1_16b(0x3333); mask[1][1] = vec128_set1_16b(0xCCCC); mask[2][0] = vec128_set1_16b(0x0F0F); mask[2][1] = vec128_set1_16b(0xF0F0); mask[3][0] = vec128_set1_16b(0x00FF); mask[3][1] = vec128_set1_16b(0xFF00); interleave(buf, 0, 8, mask[3], 3); interleave(buf, 1, 9, mask[3], 3); interleave(buf, 2, 10, mask[3], 3); interleave(buf, 3, 11, mask[3], 3); interleave(buf, 4, 12, mask[3], 3); interleave(buf, 5, 13, mask[3], 3); interleave(buf, 6, 14, mask[3], 3); interleave(buf, 7, 15, mask[3], 3); interleave(buf, 0, 4, mask[2], 2); interleave(buf, 1, 5, mask[2], 2); interleave(buf, 2, 6, mask[2], 2); interleave(buf, 3, 7, mask[2], 2); interleave(buf, 8, 12, mask[2], 2); interleave(buf, 9, 13, mask[2], 2); interleave(buf, 10, 14, mask[2], 2); interleave(buf, 11, 15, mask[2], 2); interleave(buf, 0, 2, mask[1], 1); interleave(buf, 1, 3, mask[1], 1); interleave(buf, 4, 6, mask[1], 1); interleave(buf, 5, 7, mask[1], 1); interleave(buf, 8, 10, mask[1], 1); interleave(buf, 9, 11, mask[1], 1); interleave(buf, 12, 14, mask[1], 1); interleave(buf, 13, 15, mask[1], 1); interleave(buf, 0, 1, mask[0], 0); interleave(buf, 2, 3, mask[0], 0); interleave(buf, 4, 5, mask[0], 0); interleave(buf, 6, 7, mask[0], 0); interleave(buf, 8, 9, mask[0], 0); interleave(buf, 10, 11, mask[0], 0); interleave(buf, 12, 13, mask[0], 0); interleave(buf, 14, 15, mask[0], 0); for (i = 0; i < 16; i++) for (k = 0; k < 4; k++) { out[ (4*0 + k)*16 + i ] = (vec128_extract(buf[i], 0) >> (k*16)) & GFMASK; out[ (4*1 + k)*16 + i ] = (vec128_extract(buf[i], 1) >> (k*16)) & GFMASK; } } /* input: in, field elements in bitsliced form */ /* output: out, field elements in non-bitsliced form */ void bm(uint64_t out[ GFBITS ], vec128 in[ GFBITS ]) { uint16_t i; uint16_t N, L; uint64_t prod[ GFBITS ]; uint64_t in_tmp[ GFBITS ]; ALIGN(32) uint64_t db[ GFBITS ][ 2 ]; ALIGN(32) uint64_t BC_tmp[ GFBITS ][ 2 ]; ALIGN(32) uint64_t BC[ GFBITS ][ 2 ]; uint64_t mask, t; gf d, b, c0=1; gf coefs[SYS_T * 2]; // init BC[0][1] = 0; BC[0][0] = 1; BC[0][0] <<= 63; for (i = 1; i < GFBITS; i++) BC[i][0] = BC[i][1] = 0; b = 1; L = 0; // get_coefs(coefs, in); for (i = 0; i < GFBITS; i++) in_tmp[i] = 0; for (N = 0; N < SYS_T * 2; N++) { // computing d vec_mul_sp(prod, in_tmp, &BC[0][0]); update_asm(in_tmp, coefs[N], 8); d = vec_reduce_asm(prod); t = gf_mul2(c0, coefs[N], b); d ^= t & 0xFFFFFFFF; // 3 cases mask = mask_nonzero(d) & mask_leq(L*2, N); for (i = 0; i < GFBITS; i++) { db[i][0] = (d >> i) & 1; db[i][0] = -db[i][0]; db[i][1] = (b >> i) & 1; db[i][1] = -db[i][1]; } vec128_mul((vec128*) BC_tmp, (vec128*) db, (vec128*) BC); vec_cmov(BC, mask); update_asm(BC, mask & c0, 16); for (i = 0; i < GFBITS; i++) BC[i][1] = BC_tmp[i][0] ^ BC_tmp[i][1]; c0 = t >> 32; b = (d & mask) | (b & ~mask); L = ((N+1-L) & mask) | (L & ~mask); } c0 = gf_inv(c0); for (i = 0; i < GFBITS; i++) { out[i] = (c0 >> i) & 1; out[i] = -out[i]; } vec_mul_sp(out, out, &BC[0][0]); } libmceliece-20230612/crypto_kem/348864/avx/bm.h0000644000000000000000000000044614441554466017230 0ustar rootroot/* This file is for the inversion-free Berlekamp-Massey algorithm see https://ieeexplore.ieee.org/document/87857 */ // 20221230 djb: changed * to [GFBITS] #ifndef BM_H #define BM_H #define bm CRYPTO_NAMESPACE(bm) #include "vec128.h" void bm(uint64_t [GFBITS], vec128 [GFBITS]); #endif libmceliece-20230612/crypto_kem/348864/avx/consts.S0000644000000000000000000000572514441554466020123 0ustar rootroot// 20221231 djb: port hidden to macos; tnx thom wiggers // 20221230 djb: add linker lines // linker define MASK0_0 MASK1_0 MASK2_0 MASK3_0 MASK4_0 MASK5_0 // linker define MASK0_1 MASK1_1 MASK2_1 MASK3_1 MASK4_1 MASK5_1 #include "crypto_asm_hidden.h" #define MASK0_0 CRYPTO_SHARED_NAMESPACE(MASK0_0) #define _MASK0_0 _CRYPTO_SHARED_NAMESPACE(MASK0_0) #define MASK0_1 CRYPTO_SHARED_NAMESPACE(MASK0_1) #define _MASK0_1 _CRYPTO_SHARED_NAMESPACE(MASK0_1) #define MASK1_0 CRYPTO_SHARED_NAMESPACE(MASK1_0) #define _MASK1_0 _CRYPTO_SHARED_NAMESPACE(MASK1_0) #define MASK1_1 CRYPTO_SHARED_NAMESPACE(MASK1_1) #define _MASK1_1 _CRYPTO_SHARED_NAMESPACE(MASK1_1) #define MASK2_0 CRYPTO_SHARED_NAMESPACE(MASK2_0) #define _MASK2_0 _CRYPTO_SHARED_NAMESPACE(MASK2_0) #define MASK2_1 CRYPTO_SHARED_NAMESPACE(MASK2_1) #define _MASK2_1 _CRYPTO_SHARED_NAMESPACE(MASK2_1) #define MASK3_0 CRYPTO_SHARED_NAMESPACE(MASK3_0) #define _MASK3_0 _CRYPTO_SHARED_NAMESPACE(MASK3_0) #define MASK3_1 CRYPTO_SHARED_NAMESPACE(MASK3_1) #define _MASK3_1 _CRYPTO_SHARED_NAMESPACE(MASK3_1) #define MASK4_0 CRYPTO_SHARED_NAMESPACE(MASK4_0) #define _MASK4_0 _CRYPTO_SHARED_NAMESPACE(MASK4_0) #define MASK4_1 CRYPTO_SHARED_NAMESPACE(MASK4_1) #define _MASK4_1 _CRYPTO_SHARED_NAMESPACE(MASK4_1) #define MASK5_0 CRYPTO_SHARED_NAMESPACE(MASK5_0) #define _MASK5_0 _CRYPTO_SHARED_NAMESPACE(MASK5_0) #define MASK5_1 CRYPTO_SHARED_NAMESPACE(MASK5_1) #define _MASK5_1 _CRYPTO_SHARED_NAMESPACE(MASK5_1) .data .section .rodata ASM_HIDDEN MASK0_0 ASM_HIDDEN MASK0_1 ASM_HIDDEN MASK1_0 ASM_HIDDEN MASK1_1 ASM_HIDDEN MASK2_0 ASM_HIDDEN MASK2_1 ASM_HIDDEN MASK3_0 ASM_HIDDEN MASK3_1 ASM_HIDDEN MASK4_0 ASM_HIDDEN MASK4_1 ASM_HIDDEN MASK5_0 ASM_HIDDEN MASK5_1 .globl MASK0_0 .globl MASK0_1 .globl MASK1_0 .globl MASK1_1 .globl MASK2_0 .globl MASK2_1 .globl MASK3_0 .globl MASK3_1 .globl MASK4_0 .globl MASK4_1 .globl MASK5_0 .globl MASK5_1 .p2align 5 MASK0_0: .quad 0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555 MASK0_1: .quad 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA MASK1_0: .quad 0x3333333333333333, 0x3333333333333333, 0x3333333333333333, 0x3333333333333333 MASK1_1: .quad 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC MASK2_0: .quad 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F MASK2_1: .quad 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0 MASK3_0: .quad 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF MASK3_1: .quad 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00 MASK4_0: .quad 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF MASK4_1: .quad 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000 MASK5_0: .quad 0x00000000FFFFFFFF, 0x00000000FFFFFFFF, 0x00000000FFFFFFFF, 0x00000000FFFFFFFF MASK5_1: .quad 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000 libmceliece-20230612/crypto_kem/348864/avx/consts.data0000644000000000000000000004601114441554466020623 0ustar rootroot{ vec256_set4x(0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0), vec256_set4x(0xF0F00F0F0F0FF0F0, 0xF0F00F0F0F0FF0F0, 0xF0F00F0F0F0FF0F0, 0xF0F00F0F0F0FF0F0), vec256_set4x(0x0FF00FF00FF00FF0, 0x0FF00FF00FF00FF0, 0x0FF00FF00FF00FF0, 0x0FF00FF00FF00FF0), vec256_set4x(0xAA5555AAAA5555AA, 0xAA5555AAAA5555AA, 0xAA5555AAAA5555AA, 0xAA5555AAAA5555AA), vec256_set4x(0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0), vec256_set4x(0x33CCCC33CC3333CC, 0x33CCCC33CC3333CC, 0x33CCCC33CC3333CC, 0x33CCCC33CC3333CC), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xCC33CC3333CC33CC, 0xCC33CC3333CC33CC, 0xCC33CC3333CC33CC, 0xCC33CC3333CC33CC), vec256_set4x(0x33CC33CC33CC33CC, 0x33CC33CC33CC33CC, 0x33CC33CC33CC33CC, 0x33CC33CC33CC33CC), vec256_set4x(0x5A5A5A5A5A5A5A5A, 0x5A5A5A5A5A5A5A5A, 0x5A5A5A5A5A5A5A5A, 0x5A5A5A5A5A5A5A5A), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0, 0xF00F0FF0F00F0FF0), }, { vec256_set4x(0x3C3C3C3C3C3C3C3C, 0x3C3C3C3C3C3C3C3C, 0x3C3C3C3C3C3C3C3C, 0x3C3C3C3C3C3C3C3C), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x5555AAAA5555AAAA, 0xAAAA5555AAAA5555, 0x5555AAAA5555AAAA, 0xAAAA5555AAAA5555), vec256_set4x(0xCC3333CCCC3333CC, 0xCC3333CCCC3333CC, 0xCC3333CCCC3333CC, 0xCC3333CCCC3333CC), vec256_set4x(0xC33CC33CC33CC33C, 0xC33CC33CC33CC33C, 0xC33CC33CC33CC33C, 0xC33CC33CC33CC33C), vec256_set4x(0x55555555AAAAAAAA, 0x55555555AAAAAAAA, 0x55555555AAAAAAAA, 0x55555555AAAAAAAA), vec256_set4x(0x33333333CCCCCCCC, 0x33333333CCCCCCCC, 0x33333333CCCCCCCC, 0x33333333CCCCCCCC), vec256_set4x(0x00FF00FFFF00FF00, 0xFF00FF0000FF00FF, 0x00FF00FFFF00FF00, 0xFF00FF0000FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000FFFFFFFF0000, 0x0000FFFFFFFF0000, 0x0000FFFFFFFF0000, 0x0000FFFFFFFF0000), vec256_set4x(0xF0F00F0F0F0FF0F0, 0xF0F00F0F0F0FF0F0, 0xF0F00F0F0F0FF0F0, 0xF0F00F0F0F0FF0F0), }, { vec256_set4x(0xAA55AA5555AA55AA, 0x55AA55AAAA55AA55, 0xAA55AA5555AA55AA, 0x55AA55AAAA55AA55), vec256_set4x(0xCC33CC3333CC33CC, 0xCC33CC3333CC33CC, 0x33CC33CCCC33CC33, 0x33CC33CCCC33CC33), vec256_set4x(0x33CCCC33CC3333CC, 0xCC3333CC33CCCC33, 0xCC3333CC33CCCC33, 0x33CCCC33CC3333CC), vec256_set4x(0x55555555AAAAAAAA, 0x55555555AAAAAAAA, 0x55555555AAAAAAAA, 0x55555555AAAAAAAA), vec256_set4x(0xFF0000FF00FFFF00, 0xFF0000FF00FFFF00, 0x00FFFF00FF0000FF, 0x00FFFF00FF0000FF), vec256_set4x(0x3CC33CC3C33CC33C, 0xC33CC33C3CC33CC3, 0x3CC33CC3C33CC33C, 0xC33CC33C3CC33CC3), vec256_set4x(0x5555AAAA5555AAAA, 0xAAAA5555AAAA5555, 0x5555AAAA5555AAAA, 0xAAAA5555AAAA5555), vec256_set4x(0x0FF00FF00FF00FF0, 0xF00FF00FF00FF00F, 0x0FF00FF00FF00FF0, 0xF00FF00FF00FF00F), vec256_set4x(0xCCCC33333333CCCC, 0x3333CCCCCCCC3333, 0x3333CCCCCCCC3333, 0xCCCC33333333CCCC), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x00FFFF0000FFFF00, 0xFF0000FFFF0000FF, 0x00FFFF0000FFFF00, 0xFF0000FFFF0000FF), vec256_set4x(0xC33CC33CC33CC33C, 0xC33CC33CC33CC33C, 0xC33CC33CC33CC33C, 0xC33CC33CC33CC33C), }, { vec256_set4x(0x6699669999669966, 0x9966996666996699, 0x6699669999669966, 0x9966996666996699), vec256_set4x(0x33CCCC33CC3333CC, 0x33CCCC33CC3333CC, 0x33CCCC33CC3333CC, 0x33CCCC33CC3333CC), vec256_set4x(0xA5A5A5A55A5A5A5A, 0xA5A5A5A55A5A5A5A, 0x5A5A5A5AA5A5A5A5, 0x5A5A5A5AA5A5A5A5), vec256_set4x(0x3C3CC3C3C3C33C3C, 0x3C3CC3C3C3C33C3C, 0xC3C33C3C3C3CC3C3, 0xC3C33C3C3C3CC3C3), vec256_set4x(0xF00FF00F0FF00FF0, 0x0FF00FF0F00FF00F, 0x0FF00FF0F00FF00F, 0xF00FF00F0FF00FF0), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x3C3CC3C3C3C33C3C, 0x3C3CC3C3C3C33C3C, 0xC3C33C3C3C3CC3C3, 0xC3C33C3C3C3CC3C3), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0xF0F0F0F00F0F0F0F, 0x0F0F0F0FF0F0F0F0, 0xF0F0F0F00F0F0F0F), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x33CCCC33CC3333CC, 0xCC3333CC33CCCC33, 0x33CCCC33CC3333CC, 0xCC3333CC33CCCC33), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A), }, { vec256_set4x(0x6699669999669966, 0x9966996666996699, 0x6699669999669966, 0x9966996666996699), vec256_set4x(0xCC3333CC33CCCC33, 0xCC3333CC33CCCC33, 0xCC3333CC33CCCC33, 0xCC3333CC33CCCC33), vec256_set4x(0x5A5A5A5AA5A5A5A5, 0x5A5A5A5AA5A5A5A5, 0xA5A5A5A55A5A5A5A, 0xA5A5A5A55A5A5A5A), vec256_set4x(0x3C3CC3C3C3C33C3C, 0x3C3CC3C3C3C33C3C, 0xC3C33C3C3C3CC3C3, 0xC3C33C3C3C3CC3C3), vec256_set4x(0x0FF00FF0F00FF00F, 0xF00FF00F0FF00FF0, 0xF00FF00F0FF00FF0, 0x0FF00FF0F00FF00F), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x3C3CC3C3C3C33C3C, 0x3C3CC3C3C3C33C3C, 0xC3C33C3C3C3CC3C3, 0xC3C33C3C3C3CC3C3), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0xF0F0F0F00F0F0F0F, 0x0F0F0F0FF0F0F0F0, 0xF0F0F0F00F0F0F0F), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x33CCCC33CC3333CC, 0xCC3333CC33CCCC33, 0x33CCCC33CC3333CC, 0xCC3333CC33CCCC33), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A), }, { vec256_set4x(0x9669699696696996, 0x9669699696696996, 0x9669699696696996, 0x9669699696696996), vec256_set4x(0x6996699669966996, 0x6996699669966996, 0x6996699669966996, 0x6996699669966996), vec256_set4x(0x6996699669966996, 0x6996699669966996, 0x6996699669966996, 0x6996699669966996), vec256_set4x(0x00FFFF0000FFFF00, 0x00FFFF0000FFFF00, 0xFF0000FFFF0000FF, 0xFF0000FFFF0000FF), vec256_set4x(0xFF00FF00FF00FF00, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0xFF00FF00FF00FF00), vec256_set4x(0xF00FF00F0FF00FF0, 0x0FF00FF0F00FF00F, 0x0FF00FF0F00FF00F, 0xF00FF00F0FF00FF0), vec256_set4x(0xF0F00F0F0F0FF0F0, 0x0F0FF0F0F0F00F0F, 0x0F0FF0F0F0F00F0F, 0xF0F00F0F0F0FF0F0), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A), vec256_set4x(0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C), vec256_set4x(0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C), }, { vec256_set4x(0x9669699696696996, 0x9669699696696996, 0x9669699696696996, 0x9669699696696996), vec256_set4x(0x6996699669966996, 0x6996699669966996, 0x6996699669966996, 0x6996699669966996), vec256_set4x(0x9669966996699669, 0x9669966996699669, 0x9669966996699669, 0x9669966996699669), vec256_set4x(0xFF0000FFFF0000FF, 0xFF0000FFFF0000FF, 0x00FFFF0000FFFF00, 0x00FFFF0000FFFF00), vec256_set4x(0x00FF00FF00FF00FF, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0x00FF00FF00FF00FF), vec256_set4x(0xF00FF00F0FF00FF0, 0x0FF00FF0F00FF00F, 0x0FF00FF0F00FF00F, 0xF00FF00F0FF00FF0), vec256_set4x(0xF0F00F0F0F0FF0F0, 0x0F0FF0F0F0F00F0F, 0x0F0FF0F0F0F00F0F, 0xF0F00F0F0F0FF0F0), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A), vec256_set4x(0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C), vec256_set4x(0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C), }, { vec256_set4x(0x9669699696696996, 0x9669699696696996, 0x9669699696696996, 0x9669699696696996), vec256_set4x(0x9669966996699669, 0x9669966996699669, 0x9669966996699669, 0x9669966996699669), vec256_set4x(0x9669966996699669, 0x9669966996699669, 0x9669966996699669, 0x9669966996699669), vec256_set4x(0x00FFFF0000FFFF00, 0x00FFFF0000FFFF00, 0xFF0000FFFF0000FF, 0xFF0000FFFF0000FF), vec256_set4x(0xFF00FF00FF00FF00, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0xFF00FF00FF00FF00), vec256_set4x(0xF00FF00F0FF00FF0, 0x0FF00FF0F00FF00F, 0x0FF00FF0F00FF00F, 0xF00FF00F0FF00FF0), vec256_set4x(0xF0F00F0F0F0FF0F0, 0x0F0FF0F0F0F00F0F, 0x0F0FF0F0F0F00F0F, 0xF0F00F0F0F0FF0F0), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A), vec256_set4x(0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C), vec256_set4x(0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C), }, { vec256_set4x(0x9669699696696996, 0x9669699696696996, 0x9669699696696996, 0x9669699696696996), vec256_set4x(0x9669966996699669, 0x9669966996699669, 0x9669966996699669, 0x9669966996699669), vec256_set4x(0x6996699669966996, 0x6996699669966996, 0x6996699669966996, 0x6996699669966996), vec256_set4x(0xFF0000FFFF0000FF, 0xFF0000FFFF0000FF, 0x00FFFF0000FFFF00, 0x00FFFF0000FFFF00), vec256_set4x(0x00FF00FF00FF00FF, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0x00FF00FF00FF00FF), vec256_set4x(0xF00FF00F0FF00FF0, 0x0FF00FF0F00FF00F, 0x0FF00FF0F00FF00F, 0xF00FF00F0FF00FF0), vec256_set4x(0xF0F00F0F0F0FF0F0, 0x0F0FF0F0F0F00F0F, 0x0F0FF0F0F0F00F0F, 0xF0F00F0F0F0FF0F0), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3, 0xC33C3CC33CC3C33C, 0x3CC3C33CC33C3CC3), vec256_set4x(0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A, 0xA55A5AA55AA5A55A), vec256_set4x(0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C, 0xC33C3CC33CC3C33C), vec256_set4x(0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C, 0x3CC3C33C3CC3C33C), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000, 0xFFFFFFFF00000000), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, libmceliece-20230612/crypto_kem/348864/avx/controlbits.c0000644000000000000000000001326014441554466021165 0ustar rootroot/* This file is for implementing the Nassimi-Sahni algorithm */ /* See David Nassimi, Sartaj Sahni "Parallel algorithms to set up the Benes permutationnetwork" */ /* See also https://cr.yp.to/papers/controlbits-20200923.pdf */ // 20221230 djb: add linker line // linker define controlbitsfrompermutation #include #include "crypto_declassify.h" #include "controlbits.h" #include "int32_sort.h" typedef int16_t int16; typedef int32_t int32; #include "crypto_int32.h" #define int32_min crypto_int32_min #include "crypto_int16.h" /* parameters: 1 <= w <= 14; n = 2^w */ /* input: permutation pi of {0,1,...,n-1} */ /* output: (2m-1)n/2 control bits at positions pos,pos+step,... */ /* output position pos is by definition 1&(out[pos/8]>>(pos&7)) */ /* caller must 0-initialize positions first */ /* temp must have space for int32[2*n] */ static void cbrecursion(unsigned char *out,long long pos,long long step,const int16 *pi,long long w,long long n,int32 *temp) { #define A temp #define B (temp+n) #define q ((int16 *) (temp+n+n/4)) /* q can start anywhere between temp+n and temp+n/2 */ long long x,i,j,k; if (w == 1) { out[pos>>3] ^= pi[0]<<(pos&7); return; } for (x = 0;x < n;++x) A[x] = ((pi[x]^1)<<16)|pi[x^1]; int32_sort(A,n); /* A = (id<<16)+pibar */ for (x = 0;x < n;++x) { int32 Ax = A[x]; int32 px = Ax&0xffff; int32 cx = int32_min(px,x); B[x] = (px<<16)|cx; } /* B = (p<<16)+c */ for (x = 0;x < n;++x) A[x] = (A[x]<<16)|x; /* A = (pibar<<16)+id */ int32_sort(A,n); /* A = (id<<16)+pibar^-1 */ for (x = 0;x < n;++x) A[x] = (A[x]<<16)+(B[x]>>16); /* A = (pibar^(-1)<<16)+pibar */ int32_sort(A,n); /* A = (id<<16)+pibar^2 */ if (w <= 10) { for (x = 0;x < n;++x) B[x] = ((A[x]&0xffff)<<10)|(B[x]&0x3ff); for (i = 1;i < w-1;++i) { /* B = (p<<10)+c */ for (x = 0;x < n;++x) A[x] = ((B[x]&~0x3ff)<<6)|x; /* A = (p<<16)+id */ int32_sort(A,n); /* A = (id<<16)+p^{-1} */ for (x = 0;x < n;++x) A[x] = (A[x]<<20)|B[x]; /* A = (p^{-1}<<20)+(p<<10)+c */ int32_sort(A,n); /* A = (id<<20)+(pp<<10)+cp */ for (x = 0;x < n;++x) { int32 ppcpx = A[x]&0xfffff; int32 ppcx = (A[x]&0xffc00)|(B[x]&0x3ff); B[x] = int32_min(ppcx,ppcpx); } } for (x = 0;x < n;++x) B[x] &= 0x3ff; } else { for (x = 0;x < n;++x) B[x] = (A[x]<<16)|(B[x]&0xffff); for (i = 1;i < w-1;++i) { /* B = (p<<16)+c */ for (x = 0;x < n;++x) A[x] = (B[x]&~0xffff)|x; int32_sort(A,n); /* A = (id<<16)+p^(-1) */ for (x = 0;x < n;++x) A[x] = (A[x]<<16)|(B[x]&0xffff); /* A = p^(-1)<<16+c */ if (i < w-2) { for (x = 0;x < n;++x) B[x] = (A[x]&~0xffff)|(B[x]>>16); /* B = (p^(-1)<<16)+p */ int32_sort(B,n); /* B = (id<<16)+p^(-2) */ for (x = 0;x < n;++x) B[x] = (B[x]<<16)|(A[x]&0xffff); /* B = (p^(-2)<<16)+c */ } int32_sort(A,n); /* A = id<<16+cp */ for (x = 0;x < n;++x) { int32 cpx = (B[x]&~0xffff)|(A[x]&0xffff); B[x] = int32_min(B[x],cpx); } } for (x = 0;x < n;++x) B[x] &= 0xffff; } for (x = 0;x < n;++x) A[x] = (((int32)pi[x])<<16)+x; int32_sort(A,n); /* A = (id<<16)+pi^(-1) */ for (j = 0;j < n/2;++j) { long long x = 2*j; int32 fj = B[x]&1; /* f[j] */ int32 Fx = x+fj; /* F[x] */ int32 Fx1 = Fx^1; /* F[x+1] */ out[pos>>3] ^= fj<<(pos&7); pos += step; B[x] = (A[x]<<16)|Fx; B[x+1] = (A[x+1]<<16)|Fx1; } /* B = (pi^(-1)<<16)+F */ int32_sort(B,n); /* B = (id<<16)+F(pi) */ pos += (2*w-3)*step*(n/2); for (k = 0;k < n/2;++k) { long long y = 2*k; int32 lk = B[y]&1; /* l[k] */ int32 Ly = y+lk; /* L[y] */ int32 Ly1 = Ly^1; /* L[y+1] */ out[pos>>3] ^= lk<<(pos&7); pos += step; A[y] = (Ly<<16)|(B[y]&0xffff); A[y+1] = (Ly1<<16)|(B[y+1]&0xffff); } /* A = (L<<16)+F(pi) */ int32_sort(A,n); /* A = (id<<16)+F(pi(L)) = (id<<16)+M */ pos -= (2*w-2)*step*(n/2); for (j = 0;j < n/2;++j) { q[j] = (A[2*j]&0xffff)>>1; q[j+n/2] = (A[2*j+1]&0xffff)>>1; } cbrecursion(out,pos,step*2,q,w-1,n/2,temp); cbrecursion(out,pos+step,step*2,q+n/2,w-1,n/2,temp); } /* input: p, an array of int16 */ /* input: n, length of p */ /* input: s, meaning that stride-2^s cswaps are performed */ /* input: cb, the control bits */ /* output: the result of apply the control bits to p */ static void layer(int16_t *p, const unsigned char *cb, int s, int n) { int i, j; int stride = 1 << s; int index = 0; int16_t d, m; for (i = 0; i < n; i += stride*2) { for (j = 0; j < stride; j++) { d = p[ i+j ] ^ p[ i+j+stride ]; m = (cb[ index >> 3 ] >> (index & 7)) & 1; m = -m; d &= m; p[ i+j ] ^= d; p[ i+j+stride ] ^= d; index++; } } } /* parameters: 1 <= w <= 14; n = 2^w */ /* input: permutation pi of {0,1,...,n-1} */ /* output: (2m-1)n/2 control bits at positions 0,1,... */ /* output position pos is by definition 1&(out[pos/8]>>(pos&7)) */ void controlbitsfrompermutation(unsigned char *out,const int16 *pi,long long w,long long n) { int32 temp[2*n]; int16 pi_test[n], diff; int i; unsigned char *ptr; while (1) { memset(out,0,(((2*w-1)*n/2)+7)/8); cbrecursion(out,0,1,pi,w,n,temp); // check for correctness for (i = 0; i < n; i++) pi_test[i] = i; ptr = out; for (i = 0; i < w; i++) { layer(pi_test, ptr, i, n); ptr += n >> 4; } for (i = w-2; i >= 0; i--) { layer(pi_test, ptr, i, n); ptr += n >> 4; } diff = 0; for (i = 0; i < n; i++) diff |= pi[i] ^ pi_test[i]; diff = crypto_int16_nonzero_mask(diff); crypto_declassify(&diff,sizeof diff); if (diff == 0) break; } } libmceliece-20230612/crypto_kem/348864/avx/controlbits.h0000644000000000000000000000073614441554466021176 0ustar rootroot/* This file is for implementing the Nassimi-Sahni algorithm */ /* See David Nassimi, Sartaj Sahni "Parallel algorithms to set up the Benes permutationnetwork" */ /* See also https://cr.yp.to/papers/controlbits-20200923.pdf */ #ifndef CONTROLBITS_H #define CONTROLBITS_H #define controlbitsfrompermutation CRYPTO_NAMESPACE(controlbitsfrompermutation) #include extern void controlbitsfrompermutation(unsigned char *,const int16_t *,long long,long long); #endif libmceliece-20230612/crypto_kem/348864/avx/decrypt.c0000644000000000000000000001134114441554466020273 0ustar rootroot/* This file is for Niederreiter decryption */ // 20221230 djb: add linker lines // linker define decrypt // linker use benes bm fft fft_tr // linker use load_bits // linker use vec256_mul_asm vec256_sq vec256_inv #include "decrypt.h" #include "params.h" #include "fft_tr.h" #include "benes.h" #include "util.h" #include "fft.h" #include "bm.h" #include static void scaling(vec256 out[][GFBITS], vec256 inv[][GFBITS], const unsigned char *sk, vec256 *recv) { int i, j; uint64_t sk_int[ GFBITS ]; vec256 eval[16][ GFBITS ]; vec256 tmp[ GFBITS ]; // computing inverses irr_load(sk_int, sk); fft(eval, sk_int); for (i = 0; i < 16; i++) vec256_sq(eval[i], eval[i]); vec256_copy(inv[0], eval[0]); for (i = 1; i < 16; i++) vec256_mul(inv[i], inv[i-1], eval[i]); vec256_inv(tmp, inv[15]); for (i = 14; i >= 0; i--) { vec256_mul(inv[i+1], tmp, inv[i]); vec256_mul(tmp, tmp, eval[i+1]); } vec256_copy(inv[0], tmp); // for (i = 0; i < 16; i++) for (j = 0; j < GFBITS; j++) out[i][j] = vec256_and(inv[i][j], recv[i]); } static void preprocess(vec128 *recv, const unsigned char *s) { int i; unsigned char r[ 512 ]; for (i = 0; i < SYND_BYTES; i++) r[i] = s[i]; for (i = SYND_BYTES; i < 512; i++) r[i] = 0; for (i = 0; i < 32; i++) recv[i] = load16(r + i*16); } static void postprocess(unsigned char * e, vec128 * err) { int i; unsigned char error8[ (1 << GFBITS)/8 ]; uint64_t v[2]; for (i = 0; i < 32; i++) { v[0] = vec128_extract(err[i], 0); v[1] = vec128_extract(err[i], 1); store8(error8 + i*16 + 0, v[0]); store8(error8 + i*16 + 8, v[1]); } for (i = 0; i < SYS_N/8; i++) e[i] = error8[i]; } static void scaling_inv(vec256 out[][GFBITS], vec256 inv[][GFBITS], vec256 *recv) { int i, j; for (i = 0; i < 16; i++) for (j = 0; j < GFBITS; j++) out[i][j] = vec256_and(inv[i][j], recv[i]); } static int weight_check(unsigned char * e, vec128 * error) { int i; uint16_t w0 = 0; uint16_t w1 = 0; uint16_t check; for (i = 0; i < 32; i++) { w0 += __builtin_popcountll( vec128_extract(error[i], 0) ); w0 += __builtin_popcountll( vec128_extract(error[i], 1) ); } for (i = 0; i < SYS_N/8; i++) w1 += __builtin_popcountll( e[i] ); check = (w0 ^ SYS_T) | (w1 ^ SYS_T); check -= 1; check >>= 15; return check; } static uint64_t synd_cmp(vec128 *s0 , vec128 *s1) { int i; vec128 diff; diff = vec128_xor(s0[0], s1[0]); for (i = 1; i < GFBITS; i++) diff = vec128_or(diff, vec128_xor(s0[i], s1[i])); return vec128_testz(diff); } static void reformat_128to256(vec256 * out, vec128 * in) { int i; uint64_t v[4]; for (i = 0; i < 16; i++) { v[0] = vec128_extract(in[2*i+0], 0); v[1] = vec128_extract(in[2*i+0], 1); v[2] = vec128_extract(in[2*i+1], 0); v[3] = vec128_extract(in[2*i+1], 1); out[i] = vec256_set4x(v[0], v[1], v[2], v[3]); } } static void reformat_256to128(vec128 * out, vec256 * in) { int i; uint64_t v[4]; for (i = 0; i < 16; i++) { v[0] = vec256_extract(in[i], 0); v[1] = vec256_extract(in[i], 1); v[2] = vec256_extract(in[i], 2); v[3] = vec256_extract(in[i], 3); out[2*i+0] = vec128_set2x(v[0], v[1]); out[2*i+1] = vec128_set2x(v[2], v[3]); } } /* Niederreiter decryption with the Berlekamp decoder */ /* intput: sk, secret key */ /* s, ciphertext (syndrome) */ /* output: e, error vector */ /* return: 0 for success; 1 for failure */ int decrypt(unsigned char *e, const unsigned char *sk, const unsigned char *s) { int i; uint16_t check_synd; uint16_t check_weight; vec256 inv[ 16 ][ GFBITS ]; vec256 scaled[ 16 ][ GFBITS ]; vec256 eval[16][ GFBITS ]; vec128 error128[ 32 ]; vec256 error256[ 16 ]; vec128 s_priv[ GFBITS ]; vec128 s_priv_cmp[ GFBITS ]; uint64_t locator[ GFBITS ]; vec128 recv128[ 32 ]; vec256 recv256[ 16 ]; vec256 allone; uint64_t bits_int[23][32]; // Berlekamp decoder preprocess(recv128, s); load_bits(bits_int, sk + IRR_BYTES); benes((uint64_t *) recv128, bits_int, 1); reformat_128to256(recv256, recv128); scaling(scaled, inv, sk, recv256); fft_tr(s_priv, scaled); bm(locator, s_priv); fft(eval, locator); // reencryption and weight check allone = vec256_set1_16b(0xFFFF); for (i = 0; i < 16; i++) { error256[i] = vec256_or_reduce(eval[i]); error256[i] = vec256_xor(error256[i], allone); } scaling_inv(scaled, inv, error256); fft_tr(s_priv_cmp, scaled); check_synd = synd_cmp(s_priv, s_priv_cmp); // reformat_256to128(error128, error256); benes((uint64_t *) error128, bits_int, 0); postprocess(e, error128); check_weight = weight_check(e, error128); #ifdef KAT { int k; printf("decrypt e: positions"); for (k = 0;k < SYS_N;++k) if (e[k/8] & (1 << (k&7))) printf(" %d",k); printf("\n"); } #endif return 1 - (check_synd & check_weight); } libmceliece-20230612/crypto_kem/348864/avx/decrypt.h0000644000000000000000000000032614441554466020301 0ustar rootroot/* This file is for Niederreiter decryption */ #ifndef DECRYPT_H #define DECRYPT_H #define decrypt CRYPTO_NAMESPACE(decrypt) int decrypt(unsigned char *, const unsigned char *, const unsigned char *); #endif libmceliece-20230612/crypto_kem/348864/avx/encrypt.c0000644000000000000000000000535614441554466020316 0ustar rootroot// 20230102 djb: rename encrypt() as pke_encrypt() // 20221231 djb: move encrypt.h last for macos portability; tnx thom wiggers // 20221230 djb: add linker lines // linker define pke_encrypt // linker use syndrome_asm #define syndrome_asm CRYPTO_SHARED_NAMESPACE(syndrome_asm) #define _syndrome_asm _CRYPTO_SHARED_NAMESPACE(syndrome_asm) /* This file is for Niederreiter encryption */ #include "util.h" #include "params.h" #include "int32_sort.h" #include "randombytes.h" #include "crypto_declassify.h" #include "crypto_uint16.h" #include "crypto_uint32.h" #include "encrypt.h" static inline crypto_uint16 uint16_is_smaller_declassify(uint16_t t,uint16_t u) { crypto_uint16 mask = crypto_uint16_smaller_mask(t,u); crypto_declassify(&mask,sizeof mask); return mask; } static inline crypto_uint32 uint32_is_equal_declassify(uint32_t t,uint32_t u) { crypto_uint32 mask = crypto_uint32_equal_mask(t,u); crypto_declassify(&mask,sizeof mask); return mask; } #include /* input: public key pk, error vector e */ /* output: syndrome s */ extern void syndrome_asm(unsigned char *s, const unsigned char *pk, unsigned char *e); /* output: e, an error vector of weight t */ static void gen_e(unsigned char *e) { int i, j, eq, count; union { uint16_t nums[ SYS_T*2 ]; unsigned char bytes[ SYS_T*2 * sizeof(uint16_t) ]; } buf; int32_t ind[ SYS_T ]; // can also use uint16 or int16 uint64_t e_int[ (SYS_N+63)/64 ]; uint64_t one = 1; uint64_t mask; uint64_t val[ SYS_T ]; while (1) { randombytes(buf.bytes, sizeof(buf)); for (i = 0; i < SYS_T*2; i++) buf.nums[i] = load_gf(buf.bytes + i*2); // moving and counting indices in the correct range count = 0; for (i = 0; i < SYS_T*2 && count < SYS_T; i++) if (uint16_is_smaller_declassify(buf.nums[i],SYS_N)) ind[ count++ ] = buf.nums[i]; if (count < SYS_T) continue; // check for repetition int32_sort(ind, SYS_T); eq = 0; for (i = 1; i < SYS_T; i++) if (uint32_is_equal_declassify(ind[i-1],ind[i])) eq = 1; if (eq == 0) break; } for (j = 0; j < SYS_T; j++) val[j] = one << (ind[j] & 63); for (i = 0; i < (SYS_N+63)/64; i++) { e_int[i] = 0; for (j = 0; j < SYS_T; j++) { mask = i ^ (ind[j] >> 6); mask -= 1; mask >>= 63; mask = -mask; e_int[i] |= val[j] & mask; } } for (i = 0; i < (SYS_N+63)/64 - 1; i++) { store8(e, e_int[i]); e += 8; } for (j = 0; j < (SYS_N % 64); j+=8) e[ j/8 ] = (e_int[i] >> j) & 0xFF; } void pke_encrypt(unsigned char *s, const unsigned char *pk, unsigned char *e) { gen_e(e); #ifdef KAT { int k; printf("encrypt e: positions"); for (k = 0;k < SYS_N;++k) if (e[k/8] & (1 << (k&7))) printf(" %d",k); printf("\n"); } #endif syndrome_asm(s, pk, e); } libmceliece-20230612/crypto_kem/348864/avx/encrypt.h0000644000000000000000000000042014441554466020306 0ustar rootroot/* This file is for Niederreiter encryption */ // 20230102 djb: rename encrypt() as pke_encrypt() #ifndef ENCRYPT_H #define ENCRYPT_H #define pke_encrypt CRYPTO_NAMESPACE(pke_encrypt) void pke_encrypt(unsigned char *, const unsigned char *, unsigned char *); #endif libmceliece-20230612/crypto_kem/348864/avx/fft.c0000644000000000000000000000750014441554466017402 0ustar rootroot/* This file is for implementing the Gao-Mateer FFT, see http://www.math.clemson.edu/~sgao/papers/GM10.pdf For the implementation strategy, see https://eprint.iacr.org/2017/793.pdf */ // 20221230 djb: split these arrays into separate .c files // 20221230 djb: rename powers array as fft_powers // 20221230 djb: rename consts array as fft_consts // 20221230 djb: rename s array as fft_scalars // 20221230 djb: add linker lines // linker define fft // linker use vec_mul_asm // linker use vec256_mul_asm // linker use fft_scalars fft_consts fft_powers #include "fft.h" #include "fft_scalars.h" #include "fft_consts.h" #include "fft_powers.h" #include "vec.h" /* input: in, polynomial in bitsliced form */ /* output: in, result of applying the radix conversions on in */ static void radix_conversions(uint64_t *in) { int i, j, k; const uint64_t mask[5][2] = { {0x8888888888888888, 0x4444444444444444}, {0xC0C0C0C0C0C0C0C0, 0x3030303030303030}, {0xF000F000F000F000, 0x0F000F000F000F00}, {0xFF000000FF000000, 0x00FF000000FF0000}, {0xFFFF000000000000, 0x0000FFFF00000000} }; // for (j = 0; j <= 4; j++) { for (i = 0; i < GFBITS; i++) for (k = 4; k >= j; k--) { in[i] ^= (in[i] & mask[k][0]) >> (1 << k); in[i] ^= (in[i] & mask[k][1]) >> (1 << k); } vec_mul(in, in, fft_scalars[j]); // scaling } } /* input: in, result of applying the radix conversions to the input polynomial */ /* output: out, evaluation results (by applying the FFT butterflies) */ static void butterflies(vec256 out[][ GFBITS ], uint64_t *in) { int i, j, k, s, b; uint64_t t0, t1, t2, t3; uint64_t consts_ptr = 0; const unsigned char reversal[64] = { 0, 32, 16, 48, 8, 40, 24, 56, 4, 36, 20, 52, 12, 44, 28, 60, 2, 34, 18, 50, 10, 42, 26, 58, 6, 38, 22, 54, 14, 46, 30, 62, 1, 33, 17, 49, 9, 41, 25, 57, 5, 37, 21, 53, 13, 45, 29, 61, 3, 35, 19, 51, 11, 43, 27, 59, 7, 39, 23, 55, 15, 47, 31, 63 }; // boradcast vec256 tmp256[ GFBITS ]; vec256 x[ GFBITS ], y[ GFBITS ]; for (j = 0; j < 64; j+=8) for (i = 0; i < GFBITS; i++) { t0 = (in[i] >> reversal[j+0]) & 1; t0 = -t0; t1 = (in[i] >> reversal[j+2]) & 1; t1 = -t1; t2 = (in[i] >> reversal[j+4]) & 1; t2 = -t2; t3 = (in[i] >> reversal[j+6]) & 1; t3 = -t3; out[j/4+0][i] = vec256_set4x(t0, t1, t2, t3); t0 = (in[i] >> reversal[j+1]) & 1; t0 = -t0; t1 = (in[i] >> reversal[j+3]) & 1; t1 = -t1; t2 = (in[i] >> reversal[j+5]) & 1; t2 = -t2; t3 = (in[i] >> reversal[j+7]) & 1; t3 = -t3; out[j/4+1][i] = vec256_set4x(t0, t1, t2, t3); } // for (i = 0; i < 16; i+=2) { vec256_mul(tmp256, out[i+1], fft_consts[ 0 ]); for (b = 0; b < GFBITS; b++) out[i+0][b] ^= tmp256[b]; for (b = 0; b < GFBITS; b++) out[i+1][b] ^= out[i+0][b]; } for (i = 0; i < 16; i+=2) { for (b = 0; b < GFBITS; b++) x[b] = vec256_unpack_low_2x(out[i+0][b], out[i+1][b]); for (b = 0; b < GFBITS; b++) y[b] = vec256_unpack_high_2x(out[i+0][b], out[i+1][b]); vec256_mul(tmp256, y, fft_consts[ 1 ]); for (b = 0; b < GFBITS; b++) x[b] ^= tmp256[b]; for (b = 0; b < GFBITS; b++) y[b] ^= x[b]; for (b = 0; b < GFBITS; b++) out[i+0][b] = vec256_unpack_low(x[b], y[b]); for (b = 0; b < GFBITS; b++) out[i+1][b] = vec256_unpack_high(x[b], y[b]); } consts_ptr = 2; for (i = 0; i <= 3; i++) { s = 1 << i; for (j = 0; j < 16; j += 2*s) { for (k = j; k < j+s; k++) { vec256_mul(tmp256, out[k+s], fft_consts[ consts_ptr + (k-j) ]); for (b = 0; b < GFBITS; b++) out[k][b] ^= tmp256[b]; for (b = 0; b < GFBITS; b++) out[k+s][b] ^= out[k][b]; } } consts_ptr += s; } // adding the part contributed by x^64 for (i = 0; i < 16; i++) for (b = 0; b < GFBITS; b++) out[i][b] = vec256_xor(out[i][b], fft_powers[i][b]); } void fft(vec256 out[][ GFBITS ], uint64_t *in) { radix_conversions(in); butterflies(out, in); } libmceliece-20230612/crypto_kem/348864/avx/fft.h0000644000000000000000000000044714441554467017413 0ustar rootroot/* This file is for the Gao-Mateer FFT sse http://www.math.clemson.edu/~sgao/papers/GM10.pdf */ #ifndef FFT_H #define FFT_H #define fft CRYPTO_NAMESPACE(fft) #include #include "params.h" #include "vec128.h" #include "vec256.h" void fft(vec256 [][GFBITS], uint64_t *); #endif libmceliece-20230612/crypto_kem/348864/avx/fft_consts.h0000644000000000000000000000032414441554467020776 0ustar rootroot#ifndef fft_consts_h #define fft_consts_h #include #include "params.h" #include "vec256.h" #define fft_consts CRYPTO_SHARED_NAMESPACE(fft_consts) extern const vec256 fft_consts[17][GFBITS]; #endif libmceliece-20230612/crypto_kem/348864/avx/fft_powers.h0000644000000000000000000000032414441554467021004 0ustar rootroot#ifndef fft_powers_h #define fft_powers_h #include #include "params.h" #include "vec256.h" #define fft_powers CRYPTO_SHARED_NAMESPACE(fft_powers) extern const vec256 fft_powers[16][GFBITS]; #endif libmceliece-20230612/crypto_kem/348864/avx/fft_scalars.h0000644000000000000000000000030614441554467021115 0ustar rootroot#ifndef fft_scalars_h #define fft_scalars_h #include #include "params.h" #define fft_scalars CRYPTO_SHARED_NAMESPACE(fft_scalars) extern const uint64_t fft_scalars[5][GFBITS]; #endif libmceliece-20230612/crypto_kem/348864/avx/fft_scalars_2x.h0000644000000000000000000000034714441554467021533 0ustar rootroot#ifndef fft_scalars_2x_h #define fft_scalars_2x_h #include #include "params.h" #include "vec128.h" #define fft_scalars_2x CRYPTO_SHARED_NAMESPACE(fft_scalars_2x) extern const vec128 fft_scalars_2x[5][GFBITS]; #endif libmceliece-20230612/crypto_kem/348864/avx/fft_tr.c0000644000000000000000000002700714441554467020114 0ustar rootroot/* This file is for transpose of the Gao-Mateer FFT Functions with names ending with _tr are (roughly) the transpose of the corresponding functions in fft.c For the implementation strategy, see https://eprint.iacr.org/2017/793.pdf */ // 20221230 djb: split these arrays into separate .c files // 20221230 djb: rename consts array as fft_consts // 20221230 djb: rename s array as fft_scalars_2x // 20221230 djb: add linker lines // linker define fft_tr // linker use vec_mul_asm // linker use vec128_mul_asm // linker use vec256_mul_asm // linker use transpose_64x256_sp_asm // linker use fft_scalars_2x fft_consts #include "fft_tr.h" #include "fft_scalars_2x.h" #include "fft_consts.h" #include "transpose.h" #include "vec.h" #include static void radix_conversions_tr(vec128 in[ GFBITS ]) { int i, j, k; const vec128 mask[10] = { vec128_set2x(0x2222222222222222, 0x2222222222222222), vec128_set2x(0x4444444444444444, 0x4444444444444444), vec128_set2x(0x0C0C0C0C0C0C0C0C, 0x0C0C0C0C0C0C0C0C), vec128_set2x(0x3030303030303030, 0x3030303030303030), vec128_set2x(0x00F000F000F000F0, 0x00F000F000F000F0), vec128_set2x(0x0F000F000F000F00, 0x0F000F000F000F00), vec128_set2x(0x0000FF000000FF00, 0x0000FF000000FF00), vec128_set2x(0x00FF000000FF0000, 0x00FF000000FF0000), vec128_set2x(0x00000000FFFF0000, 0x00000000FFFF0000), vec128_set2x(0x0000FFFF00000000, 0x0000FFFF00000000) }; uint64_t v0, v1; // for (j = 5; j >= 0; j--) { if (j < 5) vec128_mul(in, in, fft_scalars_2x[j]); for (i = 0; i < GFBITS; i++) for (k = j; k <= 4; k++) { in[i] ^= vec128_sll_2x(in[i] & mask[2*k+0], 1 << k); in[i] ^= vec128_sll_2x(in[i] & mask[2*k+1], 1 << k); } for (i = 0; i < GFBITS; i++) { v0 = vec128_extract(in[i], 0); v1 = vec128_extract(in[i], 1); v1 ^= v0 >> 32; v1 ^= v1 << 32; in[i] = vec128_set2x(v0, v1); } } } static void butterflies_tr(vec128 out[ GFBITS ], vec256 in[][ GFBITS ]) { int i, j, k, s, b; uint64_t tmp[ GFBITS ]; uint64_t pre[6][ GFBITS ]; uint64_t out64[2][64]; vec256 p2[ 6 ]; vec256 buf[64]; vec256 x[ GFBITS ], y[ GFBITS ]; vec256 tmp256[ GFBITS ]; uint64_t consts_ptr = 17; const unsigned char reversal[64] = { 0, 32, 16, 48, 8, 40, 24, 56, 4, 36, 20, 52, 12, 44, 28, 60, 2, 34, 18, 50, 10, 42, 26, 58, 6, 38, 22, 54, 14, 46, 30, 62, 1, 33, 17, 49, 9, 41, 25, 57, 5, 37, 21, 53, 13, 45, 29, 61, 3, 35, 19, 51, 11, 43, 27, 59, 7, 39, 23, 55, 15, 47, 31, 63 }; const uint16_t beta[6] = {8, 1300, 3408, 1354, 2341, 1154}; // butterflies for (i = 3; i >= 0; i--) { s = 1 << i; consts_ptr -= s; for (j = 0; j < 16; j += 2*s) { for (k = j; k < j+s; k++) { for (b = 0; b < GFBITS; b++) in[k][b] ^= in[k+s][b]; vec256_mul(tmp256, in[k], fft_consts[ consts_ptr + (k-j) ]); for (b = 0; b < GFBITS; b++) in[k+s][b] ^= tmp256[b]; } } } for (i = 0; i < 16; i+=2) { for (b = 0; b < GFBITS; b++) x[b] = vec256_unpack_low(in[i+0][b], in[i+1][b]); for (b = 0; b < GFBITS; b++) y[b] = vec256_unpack_high(in[i+0][b], in[i+1][b]); for (b = 0; b < GFBITS; b++) x[b] ^= y[b]; vec256_mul(tmp256, x, fft_consts[ 1 ]); for (b = 0; b < GFBITS; b++) y[b] ^= tmp256[b]; for (b = 0; b < GFBITS; b++) in[i+0][b] = vec256_unpack_low_2x(x[b], y[b]); for (b = 0; b < GFBITS; b++) in[i+1][b] = vec256_unpack_high_2x(x[b], y[b]); } for (i = 0; i < 16; i+=2) { for (b = 0; b < GFBITS; b++) in[i+0][b] ^= in[i+1][b]; vec256_mul(tmp256, in[i+0], fft_consts[ 0 ]); for (b = 0; b < GFBITS; b++) in[i+1][b] ^= tmp256[b]; } // transpose for (i = 0; i < GFBITS; i+=4) { for (j = 0; j < 64; j+=8) { buf[ reversal[j+0] ] = vec256_set4x(vec256_extract(in[j/4+0][i+0], 0), vec256_extract(in[j/4+0][i+1], 0), vec256_extract(in[j/4+0][i+2], 0), vec256_extract(in[j/4+0][i+3], 0)); buf[ reversal[j+1] ] = vec256_set4x(vec256_extract(in[j/4+1][i+0], 0), vec256_extract(in[j/4+1][i+1], 0), vec256_extract(in[j/4+1][i+2], 0), vec256_extract(in[j/4+1][i+3], 0)); buf[ reversal[j+2] ] = vec256_set4x(vec256_extract(in[j/4+0][i+0], 1), vec256_extract(in[j/4+0][i+1], 1), vec256_extract(in[j/4+0][i+2], 1), vec256_extract(in[j/4+0][i+3], 1)); buf[ reversal[j+3] ] = vec256_set4x(vec256_extract(in[j/4+1][i+0], 1), vec256_extract(in[j/4+1][i+1], 1), vec256_extract(in[j/4+1][i+2], 1), vec256_extract(in[j/4+1][i+3], 1)); buf[ reversal[j+4] ] = vec256_set4x(vec256_extract(in[j/4+0][i+0], 2), vec256_extract(in[j/4+0][i+1], 2), vec256_extract(in[j/4+0][i+2], 2), vec256_extract(in[j/4+0][i+3], 2)); buf[ reversal[j+5] ] = vec256_set4x(vec256_extract(in[j/4+1][i+0], 2), vec256_extract(in[j/4+1][i+1], 2), vec256_extract(in[j/4+1][i+2], 2), vec256_extract(in[j/4+1][i+3], 2)); buf[ reversal[j+6] ] = vec256_set4x(vec256_extract(in[j/4+0][i+0], 3), vec256_extract(in[j/4+0][i+1], 3), vec256_extract(in[j/4+0][i+2], 3), vec256_extract(in[j/4+0][i+3], 3)); buf[ reversal[j+7] ] = vec256_set4x(vec256_extract(in[j/4+1][i+0], 3), vec256_extract(in[j/4+1][i+1], 3), vec256_extract(in[j/4+1][i+2], 3), vec256_extract(in[j/4+1][i+3], 3)); } transpose_64x256_sp(buf); p2[0] = buf[32]; buf[33] = vec256_xor(buf[33], buf[32]); p2[1] = buf[33]; buf[35] = vec256_xor(buf[35], buf[33]); p2[0] = vec256_xor(p2[0], buf[35]); buf[34] = vec256_xor(buf[34], buf[35]); p2[2] = buf[34]; buf[38] = vec256_xor(buf[38], buf[34]); p2[0] = vec256_xor(p2[0], buf[38]); buf[39] = vec256_xor(buf[39], buf[38]); p2[1] = vec256_xor(p2[1], buf[39]); buf[37] = vec256_xor(buf[37], buf[39]); p2[0] = vec256_xor(p2[0], buf[37]); buf[36] = vec256_xor(buf[36], buf[37]); p2[3] = buf[36]; buf[44] = vec256_xor(buf[44], buf[36]); p2[0] = vec256_xor(p2[0], buf[44]); buf[45] = vec256_xor(buf[45], buf[44]); p2[1] = vec256_xor(p2[1], buf[45]); buf[47] = vec256_xor(buf[47], buf[45]); p2[0] = vec256_xor(p2[0], buf[47]); buf[46] = vec256_xor(buf[46], buf[47]); p2[2] = vec256_xor(p2[2], buf[46]); buf[42] = vec256_xor(buf[42], buf[46]); p2[0] = vec256_xor(p2[0], buf[42]); buf[43] = vec256_xor(buf[43], buf[42]); p2[1] = vec256_xor(p2[1], buf[43]); buf[41] = vec256_xor(buf[41], buf[43]); p2[0] = vec256_xor(p2[0], buf[41]); buf[40] = vec256_xor(buf[40], buf[41]); p2[4] = buf[40]; buf[56] = vec256_xor(buf[56], buf[40]); p2[0] = vec256_xor(p2[0], buf[56]); buf[57] = vec256_xor(buf[57], buf[56]); p2[1] = vec256_xor(p2[1], buf[57]); buf[59] = vec256_xor(buf[59], buf[57]); p2[0] = vec256_xor(p2[0], buf[59]); buf[58] = vec256_xor(buf[58], buf[59]); p2[2] = vec256_xor(p2[2], buf[58]); buf[62] = vec256_xor(buf[62], buf[58]); p2[0] = vec256_xor(p2[0], buf[62]); buf[63] = vec256_xor(buf[63], buf[62]); p2[1] = vec256_xor(p2[1], buf[63]); buf[61] = vec256_xor(buf[61], buf[63]); p2[0] = vec256_xor(p2[0], buf[61]); buf[60] = vec256_xor(buf[60], buf[61]); p2[3] = vec256_xor(p2[3], buf[60]); buf[52] = vec256_xor(buf[52], buf[60]); p2[0] = vec256_xor(p2[0], buf[52]); buf[53] = vec256_xor(buf[53], buf[52]); p2[1] = vec256_xor(p2[1], buf[53]); buf[55] = vec256_xor(buf[55], buf[53]); p2[0] = vec256_xor(p2[0], buf[55]); buf[54] = vec256_xor(buf[54], buf[55]); p2[2] = vec256_xor(p2[2], buf[54]); buf[50] = vec256_xor(buf[50], buf[54]); p2[0] = vec256_xor(p2[0], buf[50]); buf[51] = vec256_xor(buf[51], buf[50]); p2[1] = vec256_xor(p2[1], buf[51]); buf[49] = vec256_xor(buf[49], buf[51]); p2[0] = vec256_xor(p2[0], buf[49]); buf[48] = vec256_xor(buf[48], buf[49]); p2[5] = buf[48]; buf[16] = vec256_xor(buf[16], buf[48]); p2[0] = vec256_xor(p2[0], buf[16]); buf[17] = vec256_xor(buf[17], buf[16]); p2[1] = vec256_xor(p2[1], buf[17]); buf[19] = vec256_xor(buf[19], buf[17]); p2[0] = vec256_xor(p2[0], buf[19]); buf[18] = vec256_xor(buf[18], buf[19]); p2[2] = vec256_xor(p2[2], buf[18]); buf[22] = vec256_xor(buf[22], buf[18]); p2[0] = vec256_xor(p2[0], buf[22]); buf[23] = vec256_xor(buf[23], buf[22]); p2[1] = vec256_xor(p2[1], buf[23]); buf[21] = vec256_xor(buf[21], buf[23]); p2[0] = vec256_xor(p2[0], buf[21]); buf[20] = vec256_xor(buf[20], buf[21]); p2[3] = vec256_xor(p2[3], buf[20]); buf[28] = vec256_xor(buf[28], buf[20]); p2[0] = vec256_xor(p2[0], buf[28]); buf[29] = vec256_xor(buf[29], buf[28]); p2[1] = vec256_xor(p2[1], buf[29]); buf[31] = vec256_xor(buf[31], buf[29]); p2[0] = vec256_xor(p2[0], buf[31]); buf[30] = vec256_xor(buf[30], buf[31]); p2[2] = vec256_xor(p2[2], buf[30]); buf[26] = vec256_xor(buf[26], buf[30]); p2[0] = vec256_xor(p2[0], buf[26]); buf[27] = vec256_xor(buf[27], buf[26]); p2[1] = vec256_xor(p2[1], buf[27]); buf[25] = vec256_xor(buf[25], buf[27]); p2[0] = vec256_xor(p2[0], buf[25]); buf[24] = vec256_xor(buf[24], buf[25]); p2[4] = vec256_xor(p2[4], buf[24]); buf[8] = vec256_xor(buf[8], buf[24]); p2[0] = vec256_xor(p2[0], buf[8]); buf[9] = vec256_xor(buf[9], buf[8]); p2[1] = vec256_xor(p2[1], buf[9]); buf[11] = vec256_xor(buf[11], buf[9]); p2[0] = vec256_xor(p2[0], buf[11]); buf[10] = vec256_xor(buf[10], buf[11]); p2[2] = vec256_xor(p2[2], buf[10]); buf[14] = vec256_xor(buf[14], buf[10]); p2[0] = vec256_xor(p2[0], buf[14]); buf[15] = vec256_xor(buf[15], buf[14]); p2[1] = vec256_xor(p2[1], buf[15]); buf[13] = vec256_xor(buf[13], buf[15]); p2[0] = vec256_xor(p2[0], buf[13]); buf[12] = vec256_xor(buf[12], buf[13]); p2[3] = vec256_xor(p2[3], buf[12]); buf[4] = vec256_xor(buf[4], buf[12]); p2[0] = vec256_xor(p2[0], buf[4]); buf[5] = vec256_xor(buf[5], buf[4]); p2[1] = vec256_xor(p2[1], buf[5]); buf[7] = vec256_xor(buf[7], buf[5]); p2[0] = vec256_xor(p2[0], buf[7]); buf[6] = vec256_xor(buf[6], buf[7]); p2[2] = vec256_xor(p2[2], buf[6]); buf[2] = vec256_xor(buf[2], buf[6]); p2[0] = vec256_xor(p2[0], buf[2]); buf[3] = vec256_xor(buf[3], buf[2]); p2[1] = vec256_xor(p2[1], buf[3]); buf[1] = vec256_xor(buf[1], buf[3]); p2[0] = vec256_xor(p2[0], buf[1]); buf[0] = vec256_xor(buf[0], buf[1]); for (j = 0; j < 6; j++) { pre[j][i+0] = vec256_extract(p2[j], 0); pre[j][i+1] = vec256_extract(p2[j], 1); pre[j][i+2] = vec256_extract(p2[j], 2); pre[j][i+3] = vec256_extract(p2[j], 3); } out64[0][i+0] = vec256_extract(buf[0], 0); out64[0][i+1] = vec256_extract(buf[0], 1); out64[0][i+2] = vec256_extract(buf[0], 2); out64[0][i+3] = vec256_extract(buf[0], 3); } // for (j = 0; j < GFBITS; j++) { tmp[j] = (beta[0] >> j) & 1; tmp[j] = -tmp[j]; } vec_mul(out64[1], pre[0], tmp); for (i = 1; i < 6; i++) { for (j = 0; j < GFBITS; j++) { tmp[j] = (beta[i] >> j) & 1; tmp[j] = -tmp[j]; } vec_mul(tmp, pre[i], tmp); vec_add(out64[1], out64[1], tmp); } for (i = 0; i < GFBITS; i++) out[i] = vec128_set2x(out64[0][i], out64[1][i]); } void fft_tr(vec128 out[GFBITS], vec256 in[][ GFBITS ]) { butterflies_tr(out, in); radix_conversions_tr(out); } libmceliece-20230612/crypto_kem/348864/avx/fft_tr.h0000644000000000000000000000042114441554467020110 0ustar rootroot/* This file is for transpose of the Gao-Mateer FFT */ // 20221230 djb: changed * to [GFBITS] #ifndef FFT_TR_H #define FFT_TR_H #define fft_tr CRYPTO_NAMESPACE(fft_tr) #include "params.h" #include "vec256.h" void fft_tr(vec128 [GFBITS], vec256 [][ GFBITS ]); #endif libmceliece-20230612/crypto_kem/348864/avx/gf.c0000644000000000000000000000451614441554467017224 0ustar rootroot/* This file is for functions for field arithmetic */ // 20221231 djb: const for GF_mul // 20221230 djb: add linker line // linker define gf_iszero gf_add gf_mul gf_inv gf_frac GF_mul #include "gf.h" #include "params.h" gf gf_iszero(gf a) { uint32_t t = a; t -= 1; t >>= 20; return (gf) t; } gf gf_add(gf in0, gf in1) { return in0 ^ in1; } gf gf_mul(gf in0, gf in1) { int i; uint32_t tmp; uint32_t t0; uint32_t t1; uint32_t t; t0 = in0; t1 = in1; tmp = t0 * (t1 & 1); for (i = 1; i < GFBITS; i++) tmp ^= (t0 * (t1 & (1 << i))); t = tmp & 0x7FC000; tmp ^= t >> 9; tmp ^= t >> 12; t = tmp & 0x3000; tmp ^= t >> 9; tmp ^= t >> 12; return tmp & ((1 << GFBITS)-1); } /* input: field element in */ /* return: in^2 */ static inline gf gf_sq(gf in) { const uint32_t B[] = {0x55555555, 0x33333333, 0x0F0F0F0F, 0x00FF00FF}; uint32_t x = in; uint32_t t; x = (x | (x << 8)) & B[3]; x = (x | (x << 4)) & B[2]; x = (x | (x << 2)) & B[1]; x = (x | (x << 1)) & B[0]; t = x & 0x7FC000; x ^= t >> 9; x ^= t >> 12; t = x & 0x3000; x ^= t >> 9; x ^= t >> 12; return x & ((1 << GFBITS)-1); } gf gf_inv(gf in) { gf tmp_11; gf tmp_1111; gf out = in; out = gf_sq(out); tmp_11 = gf_mul(out, in); // 11 out = gf_sq(tmp_11); out = gf_sq(out); tmp_1111 = gf_mul(out, tmp_11); // 1111 out = gf_sq(tmp_1111); out = gf_sq(out); out = gf_sq(out); out = gf_sq(out); out = gf_mul(out, tmp_1111); // 11111111 out = gf_sq(out); out = gf_sq(out); out = gf_mul(out, tmp_11); // 1111111111 out = gf_sq(out); out = gf_mul(out, in); // 11111111111 return gf_sq(out); // 111111111110 } /* input: field element den, num */ /* return: (num/den) */ gf gf_frac(gf den, gf num) { return gf_mul(gf_inv(den), num); } /* input: in0, in1 in GF((2^m)^t)*/ /* output: out = in0*in1 */ void GF_mul(gf *out, const gf *in0, const gf *in1) { int i, j; gf prod[ SYS_T*2-1 ]; for (i = 0; i < SYS_T*2-1; i++) prod[i] = 0; for (i = 0; i < SYS_T; i++) for (j = 0; j < SYS_T; j++) prod[i+j] ^= gf_mul(in0[i], in1[j]); // for (i = (SYS_T-1)*2; i >= SYS_T; i--) { prod[i - SYS_T + 9] ^= gf_mul(prod[i], (gf) 877); prod[i - SYS_T + 7] ^= gf_mul(prod[i], (gf) 2888); prod[i - SYS_T + 5] ^= gf_mul(prod[i], (gf) 1781); prod[i - SYS_T + 0] ^= gf_mul(prod[i], (gf) 373); } for (i = 0; i < SYS_T; i++) out[i] = prod[i]; } libmceliece-20230612/crypto_kem/348864/avx/gf.h0000644000000000000000000000210614441554467017222 0ustar rootroot/* This file is for functions for field arithmetic */ // 20221231 djb: const for GF_mul #ifndef GF_H #define GF_H #define gf_add CRYPTO_NAMESPACE(gf_add) #define gf_frac CRYPTO_NAMESPACE(gf_frac) #define gf_inv CRYPTO_NAMESPACE(gf_inv) #define gf_iszero CRYPTO_NAMESPACE(gf_iszero) #define gf_mul2 CRYPTO_NAMESPACE(gf_mul2) #define gf_mul CRYPTO_NAMESPACE(gf_mul) #define GF_mul CRYPTO_NAMESPACE(GF_mul) #include "params.h" #include typedef uint16_t gf; gf gf_iszero(gf); gf gf_add(gf, gf); gf gf_mul(gf, gf); gf gf_frac(gf, gf); gf gf_inv(gf); void GF_mul(gf *, const gf *, const gf *); /* 2 field multiplications */ static inline uint64_t gf_mul2(gf a, gf b0, gf b1) { int i; uint64_t tmp=0; uint64_t t0; uint64_t t1; uint64_t t; uint64_t mask = 0x0000000100000001; t0 = a; t1 = b1; t1 = (t1 << 32) | b0; for (i = 0; i < GFBITS; i++) { tmp ^= t0 * (t1 & mask); mask += mask; } // t = tmp & 0x007FC000007FC000; tmp ^= (t >> 9) ^ (t >> 12); t = tmp & 0x0000300000003000; tmp ^= (t >> 9) ^ (t >> 12); return tmp & 0x00000FFF00000FFF; } #endif libmceliece-20230612/crypto_kem/348864/avx/hash.h0000644000000000000000000000020614441554467017550 0ustar rootroot#include "crypto_xof_shake256.h" #define shake crypto_xof_shake256 #define crypto_hash_32b(out,in,inlen) \ shake(out,32,in,inlen) libmceliece-20230612/crypto_kem/348864/avx/int32_sort.h0000644000000000000000000000017014441554467020633 0ustar rootroot#ifndef int32_sort_h #define int32_sort_h #include "crypto_sort_int32.h" #define int32_sort crypto_sort_int32 #endif libmceliece-20230612/crypto_kem/348864/avx/kem_dec.c0000644000000000000000000000160514441554467020213 0ustar rootroot// 20221230 djb: add linker lines // 20221230 djb: split out of operations.c // linker define operation_dec // linker use decrypt #include "operations.h" #include "hash.h" #include "decrypt.h" #include "params.h" #include "util.h" #include #include int operation_dec( unsigned char *key, const unsigned char *c, const unsigned char *sk ) { int i; unsigned char ret_decrypt = 0; uint16_t m; unsigned char e[ SYS_N/8 ]; unsigned char preimage[ 1 + SYS_N/8 + SYND_BYTES ]; unsigned char *x = preimage; const unsigned char *s = sk + 40 + IRR_BYTES + COND_BYTES; // ret_decrypt = decrypt(e, sk + 40, c); m = ret_decrypt; m -= 1; m >>= 8; *x++ = m & 1; for (i = 0; i < SYS_N/8; i++) *x++ = (~m & s[i]) | (m & e[i]); for (i = 0; i < SYND_BYTES; i++) *x++ = c[i]; crypto_hash_32b(key, preimage, sizeof(preimage)); return 0; } libmceliece-20230612/crypto_kem/348864/avx/kem_enc.c0000644000000000000000000000127014441554467020223 0ustar rootroot// 20230102 djb: rename encrypt() as pke_encrypt() // 20221230 djb: add linker lines // 20221230 djb: split out of operations.c // linker define operation_enc // linker use pke_encrypt #include "operations.h" #include "hash.h" #include "encrypt.h" #include "params.h" #include "util.h" #include #include int operation_enc( unsigned char *c, unsigned char *key, const unsigned char *pk ) { unsigned char e[ SYS_N/8 ]; unsigned char one_ec[ 1 + SYS_N/8 + SYND_BYTES ] = {1}; // pke_encrypt(c, pk, e); memcpy(one_ec + 1, e, SYS_N/8); memcpy(one_ec + 1 + SYS_N/8, c, SYND_BYTES); crypto_hash_32b(key, one_ec, sizeof(one_ec)); return 0; } libmceliece-20230612/crypto_kem/348864/avx/kem_keypair.c0000644000000000000000000000330614441554467021124 0ustar rootroot// 20221230 djb: add linker lines // 20221230 djb: split out of operations.c // linker define operation_keypair // linker use controlbitsfrompermutation genpoly_gen pk_gen #include "operations.h" #include "controlbits.h" #include "randombytes.h" #include "hash.h" #include "params.h" #include "sk_gen.h" #include "pk_gen.h" #include "util.h" #include #include void operation_keypair ( unsigned char *pk, unsigned char *sk ) { int i; unsigned char seed[ 33 ] = {64}; unsigned char r[ SYS_N/8 + (1 << GFBITS)*sizeof(uint32_t) + SYS_T*2 + 32 ]; unsigned char *rp, *skp; gf f[ SYS_T ]; // element in GF(2^mt) gf irr[ SYS_T ]; // Goppa polynomial uint32_t perm[ 1 << GFBITS ]; // random permutation as 32-bit integers int16_t pi[ 1 << GFBITS ]; // random permutation randombytes(seed+1, 32); while (1) { rp = &r[ sizeof(r)-32 ]; skp = sk; // expanding and updating the seed shake(r, sizeof(r), seed, 33); memcpy(skp, seed+1, 32); skp += 32 + 8; memcpy(seed+1, &r[ sizeof(r)-32 ], 32); // generating irreducible polynomial rp -= sizeof(f); for (i = 0; i < SYS_T; i++) f[i] = load_gf(rp + i*2); if (genpoly_gen(irr, f)) continue; for (i = 0; i < SYS_T; i++) store_gf(skp + i*2, irr[i]); skp += IRR_BYTES; // generating permutation rp -= sizeof(perm); for (i = 0; i < (1 << GFBITS); i++) perm[i] = load4(rp + i*4); if (pk_gen(pk, skp - IRR_BYTES, perm, pi)) continue; controlbitsfrompermutation(skp, pi, GFBITS, 1 << GFBITS); skp += COND_BYTES; // storing the random string s rp -= SYS_N/8; memcpy(skp, rp, SYS_N/8); // storing positions of the 32 pivots store8(sk + 32, 0xFFFFFFFF); break; } } libmceliece-20230612/crypto_kem/348864/avx/operations.h0000644000000000000000000000101114441554467021003 0ustar rootroot#ifndef OPERATIONS_H #define OPERATIONS_H #define operation_keypair CRYPTO_NAMESPACE(operation_keypair) #define operation_enc CRYPTO_NAMESPACE(operation_enc) #define operation_dec CRYPTO_NAMESPACE(operation_dec) int operation_enc( unsigned char *c, unsigned char *key, const unsigned char *pk ); int operation_dec( unsigned char *key, const unsigned char *c, const unsigned char *sk ); void operation_keypair ( unsigned char *pk, unsigned char *sk ); #endif libmceliece-20230612/crypto_kem/348864/avx/params.h0000644000000000000000000000056014441554467020113 0ustar rootroot#ifndef PARAMS_H #define PARAMS_H #define GFBITS 12 #define SYS_N 3488 #define SYS_T 64 #define COND_BYTES ((1 << (GFBITS-4))*(2*GFBITS - 1)) #define IRR_BYTES (SYS_T * 2) #define PK_NROWS (SYS_T*GFBITS) #define PK_NCOLS (SYS_N - PK_NROWS) #define PK_ROW_BYTES ((PK_NCOLS + 7)/8) #define SYND_BYTES ((PK_NROWS + 7)/8) #define GFMASK ((1 << GFBITS) - 1) #endif libmceliece-20230612/crypto_kem/348864/avx/pk_gen.c0000644000000000000000000002046014441554467020067 0ustar rootroot/* This file is for public-key generation */ // 20230105 tony: use merge exchange in sort_rows(); fewer lines for minmax_rows() // 20221231 djb: more 0 initialization to clarify data flow; tnx thom wiggers // 20221230 djb: add linker lines // 20221230 djb: move nBlocks_I to macro // linker define pk_gen // linker use fft vec256_inv vec256_mul_asm #include "pk_gen.h" #include "uint64_sort.h" #include "int32_sort.h" #include "params.h" #include "util.h" #include "fft.h" #include "crypto_declassify.h" #include "crypto_uint64.h" static crypto_uint64 uint64_is_equal_declassify(uint64_t t,uint64_t u) { crypto_uint64 mask = crypto_uint64_equal_mask(t,u); crypto_declassify(&mask,sizeof mask); return mask; } static crypto_uint64 uint64_is_zero_declassify(uint64_t t) { crypto_uint64 mask = crypto_uint64_zero_mask(t); crypto_declassify(&mask,sizeof mask); return mask; } #include #define nBlocks_I ((PK_NROWS + 255) / 256) #define par_width 11 /* set m to 11...1 if the i-th bit of x is 0 and the i-th bit of y is 1 */ /* set m to 00...0 otherwise */ static inline void extract_01_masks(uint16_t *m, uint64_t *x, uint64_t *y, int i) { *m = (((~x[ i>>6 ]) & y[ i>>6 ]) >> (i&63)) & 1; *m = -(*m); } /* return a 128-bit vector of which each bits is set to the i-th bit of v */ static inline vec256 extract_mask256(uint64_t v[], int i) { uint32_t mask; mask = (v[ i>>6 ] >> (i&63)) & 1; mask = -mask; return vec256_set1_32b(mask); } // swap x and y if m = 11...1 static inline void uint16_cswap(uint16_t *x, uint16_t *y, uint16_t m) { uint16_t d; d = *x ^ *y; d &= m; *x ^= d; *y ^= d; } // swap x and y if m = 11...1 static inline void vec256_cswap(vec256 *x, vec256 *y, vec256 m) { vec256 d; d = *x ^ *y; d &= m; *x ^= d; *y ^= d; } /* swap x[i0] and x[i1] if x[i1] > x[i0] */ /* swap mat[i0] and mat[i1] if x[i1] > x[i0] */ static inline void minmax_rows(uint16_t *x, vec256 (*mat)[par_width], int i0, int i1) { int i; uint16_t m; vec256 mm; m = x[i1] - x[i0]; m >>= 15; m = -m; mm = vec256_set1_16b(m); uint16_cswap(&x[i0], &x[i1], m); for (i = 0; i < par_width; i++) vec256_cswap(&mat[i0][i], &mat[i1][i], mm); } static void sort_rows(int n, uint16_t *x, vec256 (*mat)[par_width]) { int t = 1; while ((1 << t)*2 < n) t++; for (int j = t-1; j >= 0; j--) { int p = 1 << j, q = 1 << (t-1), r = 0, d = p; while (1) { for (int i = 0; i < n-d; i++) if ((i & p) == r) minmax_rows(x, mat, i, i+d); if (q != p) { d = q - p; q = q / 2; r = p; } else break; } } } /* extract numbers represented in bitsliced form */ static void de_bitslicing(uint64_t * out, const vec256 in[][GFBITS]) { int i, j, r; uint64_t u = 0; for (i = 0; i < (1 << GFBITS); i++) out[i] = 0 ; for (i = 0; i < 16; i++) for (j = GFBITS-1; j >= 0; j--) { u = vec256_extract(in[i][j], 0); for (r = 0; r < 64; r++) { out[i*256 + 0*64 + r] <<= 1; out[i*256 + 0*64 + r] |= (u >> r) & 1; } u = vec256_extract(in[i][j], 1); for (r = 0; r < 64; r++) { out[i*256 + 1*64 + r] <<= 1; out[i*256 + 1*64 + r] |= (u >> r) & 1; } u = vec256_extract(in[i][j], 2); for (r = 0; r < 64; r++) { out[i*256 + 2*64 + r] <<= 1; out[i*256 + 2*64 + r] |= (u >> r) & 1; } u = vec256_extract(in[i][j], 3); for (r = 0; r < 64; r++) { out[i*256 + 3*64 + r] <<= 1; out[i*256 + 3*64 + r] |= (u >> r) & 1; } } } /* convert numbers into bitsliced form */ static void to_bitslicing_2x(vec256 out0[][GFBITS], vec256 out1[][GFBITS], const uint64_t * in) { int i, j, k, r; uint64_t u[2][4]; for (j = 0;j < 2;++j) for (k = 0;k < 4;++k) u[j][k] = 0; for (i = 0; i < 16; i++) for (j = GFBITS-1; j >= 0; j--) { for (k = 0; k < 4; k++) for (r = 63; r >= 0; r--) { u[0][k] <<= 1; u[0][k] |= (in[i*256 + k*64 + r] >> (GFBITS-1-j)) & 1; u[1][k] <<= 1; u[1][k] |= (in[i*256 + k*64 + r] >> (j + GFBITS)) & 1; } out0[i][j] = vec256_set4x(u[0][0], u[0][1], u[0][2], u[0][3]); out1[i][j] = vec256_set4x(u[1][0], u[1][1], u[1][2], u[1][3]); } } /* y[pi[i]] = x[i] */ /* requires pi to be a permutation */ static void composeinv(int n, uint16_t y[n], uint16_t x[n], uint16_t pi[n]) { int i; int32_t t[n]; for (i = 0;i < n;++i) { t[i] = pi[i]; t[i] <<= 16; t[i] |= x[i]; } int32_sort(t,n); for (i = 0;i < n;++i) y[i] = t[i] & 0xFFFF; } /* input: irr, an irreducible polynomial */ /* perm, a permutation represented as an array of 32-bit numbers */ /* pi, same permutation represented as an array of 16-bit numbers */ /* output: pk, the public key*/ /* return: 0 if pk is successfully generated, -1 otherwise */ int pk_gen(unsigned char * pk, const unsigned char * irr, uint32_t * perm, int16_t * pi) { int i, j, k, b; int row, c; union { uint64_t w[ PK_NROWS ][ nBlocks_I*4 ]; vec256 v[ PK_NROWS ][ nBlocks_I ]; } mat; union { uint64_t w[ PK_NROWS ][ par_width*4 ]; vec256 v[ PK_NROWS ][ par_width ]; } par; uint16_t m; vec256 mm; uint64_t sk_int[ GFBITS ]; vec256 consts[ 16 ][ GFBITS ]; vec256 eval[ 16 ][ GFBITS ]; vec256 prod[ 16 ][ GFBITS ]; vec256 tmp[ GFBITS ]; uint64_t list[1 << GFBITS]; uint64_t one = 1; uint64_t t; uint16_t ind[ PK_NROWS ]; uint16_t ind_inv[ PK_NROWS ]; // compute the inverses irr_load(sk_int, irr); fft(eval, sk_int); vec256_copy(prod[0], eval[0]); for (i = 1; i < 16; i++) vec256_mul(prod[i], prod[i-1], eval[i]); vec256_inv(tmp, prod[15]); for (i = 14; i >= 0; i--) { vec256_mul(prod[i+1], prod[i], tmp); vec256_mul(tmp, tmp, eval[i+1]); } vec256_copy(prod[0], tmp); // fill matrix de_bitslicing(list, prod); for (i = 0; i < (1 << GFBITS); i++) { list[i] <<= GFBITS; list[i] |= i; list[i] |= ((uint64_t) perm[i]) << 31; } uint64_sort(list, 1 << GFBITS); for (i = 1; i < (1 << GFBITS); i++) if (uint64_is_equal_declassify(list[i-1] >> 31,list[i] >> 31)) return -1; to_bitslicing_2x(consts, prod, list); for (i = 0; i < (1 << GFBITS); i++) pi[i] = list[i] & GFMASK; for (j = 0; j < nBlocks_I; j++) for (k = 0; k < GFBITS; k++) mat.v[ k ][ j ] = prod[ j ][ k ]; for (i = 1; i < SYS_T; i++) for (j = 0; j < nBlocks_I; j++) { vec256_mul(prod[j], prod[j], consts[j]); for (k = 0; k < GFBITS; k++) mat.v[ i*GFBITS + k ][ j ] = prod[ j ][ k ]; } // gaussian elimination to obtain L, U, and P such that LP M = U // L and U are stored in the space of M // P is stored in ind for (i = 0; i < PK_NROWS; i++) ind_inv[i] = ind[ i ] = i; for (row = 0; row < PK_NROWS; row++) { i = row >> 6; j = row & 63; for (k = row + 1; k < PK_NROWS; k++) { extract_01_masks(&m, mat.w[ row ], mat.w[ k ], row); uint16_cswap(&ind[row], &ind[k], m); mm = vec256_set1_16b(m); for (c = 0; c < nBlocks_I; c++) vec256_cswap(&mat.v[ row ][ c ], &mat.v[ k ][ c ], mm); } if ( uint64_is_zero_declassify((mat.w[ row ][ i ] >> j) & 1) ) // return if not systematic { return -1; } for (k = row+1; k < PK_NROWS; k++) { t = mat.w[ k ][ i ] & (one << j); mm = extract_mask256(mat.w[k], row); for (c = 0; c < nBlocks_I; c++) mat.v[ k ][ c ] ^= mat.v[ row ][ c ] & mm; mat.w[ k ][ i ] |= t; } } // apply M^-1 to the remaining columns composeinv(PK_NROWS, ind_inv, ind_inv, ind); for (k = 0; k < GFBITS; k++) { for (b = 0; b < par_width; b++) par.v[ k ][ b ] = prod[nBlocks_I + b][ k ]; } for (i = 1; i < SYS_T; i++) { for (b = 0; b < par_width; b++) vec256_mul(prod[nBlocks_I + b], prod[nBlocks_I + b], consts[nBlocks_I + b]); for (k = 0; k < GFBITS; k++) for (b = 0; b < par_width; b++) par.v[ i*GFBITS + k ][ b ] = prod[nBlocks_I + b][ k ]; } // apply P for (i = 0; i < PK_NROWS; i++) ind[i] = ind_inv[i]; sort_rows(PK_NROWS, ind, par.v); // apply L for (row = PK_NROWS-1; row >= 0; row--) for (i = row-1; i >= 0; i--) { mm = extract_mask256(mat.w[row], i); for (k = 0; k < par_width; k++) par.v[ row ][ k ] ^= par.v[ i ][ k ] & mm; } // apply U^-1 for (row = PK_NROWS-1; row >= 0; row--) for (i = PK_NROWS-1; i > row; i--) { mm = extract_mask256(mat.w[row], i); for (k = 0; k < par_width; k++) par.v[ row ][ k ] ^= par.v[ i ][ k ] & mm; } for (row = 0; row < PK_NROWS; row++) { for (k = 0; k < 42; k++) store8(pk + PK_ROW_BYTES * row + k*8, par.w[row][k]); store_i(pk + PK_ROW_BYTES * row + k*8, par.w[row][k], 4); } // return 0; } libmceliece-20230612/crypto_kem/348864/avx/pk_gen.h0000644000000000000000000000034014441554467020067 0ustar rootroot/* This file is for public-key generation */ #ifndef PK_GEN_H #define PK_GEN_H #define pk_gen CRYPTO_NAMESPACE(pk_gen) #include "gf.h" int pk_gen(unsigned char *, const unsigned char *, uint32_t *, int16_t *); #endif libmceliece-20230612/crypto_kem/348864/avx/powers.data0000644000000000000000000004364014441554467020637 0ustar rootroot{ vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, { vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, { vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC, 0x3333CCCC3333CCCC), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00, 0xFF00FF00FF00FF00), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), }, { vec256_set4x(0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F00F0F0F0F), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, { vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFF0000FFFF0000, 0xFFFF0000FFFF0000, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F), vec256_set4x(0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), vec256_set4x(0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA, 0xAA55AA55AA55AA55, 0x55AA55AA55AA55AA), vec256_set4x(0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FF0F0F0F0), vec256_set4x(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000), vec256_set4x(0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF), vec256_set4x(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0), vec256_set4x(0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333, 0xCCCC3333CCCC3333), vec256_set4x(0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555), }, libmceliece-20230612/crypto_kem/348864/avx/scalars.data0000644000000000000000000000240414441554467020741 0ustar rootroot{ 0XF3CFC030FC30F003, 0X3FCF0F003C00C00C, 0X30033CC300C0C03C, 0XCCFF0F3C0F30F0C0, 0X0300C03FF303C3F0, 0X3FFF3C0FF0CCCCC0, 0XF3FFF0C00F3C3CC0, 0X3003333FFFC3C000, 0X0FF30FFFC3FFF300, 0XFFC0F300F0F0CC00, 0XC0CFF3FCCC3CFC00, 0XFC3C03F0F330C000, }, { 0X000F00000000F00F, 0X00000F00F00000F0, 0X0F00000F00000F00, 0XF00F00F00F000000, 0X00F00000000000F0, 0X0000000F00000000, 0XF00000000F00F000, 0X00F00F00000F0000, 0X0000F00000F00F00, 0X000F00F00F00F000, 0X00F00F0000000000, 0X0000000000F00000, }, { 0X0000FF00FF0000FF, 0X0000FF000000FF00, 0XFF0000FF00FF0000, 0XFFFF0000FF000000, 0X00FF00FF00FF0000, 0X0000FFFFFF000000, 0X00FFFF00FF000000, 0XFFFFFF0000FF0000, 0XFFFF00FFFF00FF00, 0X0000FF0000000000, 0XFFFFFF00FF000000, 0X00FF000000000000, }, { 0X000000000000FFFF, 0X00000000FFFF0000, 0X0000000000000000, 0XFFFF000000000000, 0X00000000FFFF0000, 0X0000FFFF00000000, 0X0000000000000000, 0X00000000FFFF0000, 0X0000FFFF00000000, 0X0000000000000000, 0X0000000000000000, 0X0000000000000000, }, { 0X00000000FFFFFFFF, 0XFFFFFFFF00000000, 0XFFFFFFFF00000000, 0X0000000000000000, 0X0000000000000000, 0XFFFFFFFF00000000, 0X0000000000000000, 0X0000000000000000, 0XFFFFFFFF00000000, 0X0000000000000000, 0X0000000000000000, 0X0000000000000000, } libmceliece-20230612/crypto_kem/348864/avx/scalars_2x.data0000644000000000000000000000637514441554467021365 0ustar rootroot{ vec128_set2x(0xf3cfc030fc30f003, 0x000c03c0c3c0330c), vec128_set2x(0x3fcf0f003c00c00c, 0xf330cffcc00f33c0), vec128_set2x(0x30033cc300c0c03c, 0xccf330f00f3c0333), vec128_set2x(0xccff0f3c0f30f0c0, 0xff03fff3ff0cf0c0), vec128_set2x(0x0300c03ff303c3f0, 0x3cc3fcf00fcc303c), vec128_set2x(0x3fff3c0ff0ccccc0, 0x0f000c0fc30303f3), vec128_set2x(0xf3fff0c00f3c3cc0, 0xcf0fc3ff333ccf3c), vec128_set2x(0x3003333fffc3c000, 0x003f3fc3c0ff333f), vec128_set2x(0x0ff30fffc3fff300, 0x3cc3f0f3cf0ff00f), vec128_set2x(0xffc0f300f0f0cc00, 0xf3f33cc03fc30cc0), vec128_set2x(0xc0cff3fccc3cfc00, 0x3cc330cfc333f33f), vec128_set2x(0xfc3c03f0f330c000, 0x3cc0303ff3c3fffc), }, { vec128_set2x(0x000f00000000f00f, 0x0f00f00f00000000), vec128_set2x(0x00000f00f00000f0, 0xf00000000000f000), vec128_set2x(0x0f00000f00000f00, 0x00000f00000000f0), vec128_set2x(0xf00f00f00f000000, 0x0f00f00000f00000), vec128_set2x(0x00f00000000000f0, 0x000f00000f00f00f), vec128_set2x(0x0000000f00000000, 0x00f00f00f00f0000), vec128_set2x(0xf00000000f00f000, 0x0f00f00000000000), vec128_set2x(0x00f00f00000f0000, 0x000000000f000000), vec128_set2x(0x0000f00000f00f00, 0x00f00000000f00f0), vec128_set2x(0x000f00f00f00f000, 0x0000f00f00000f00), vec128_set2x(0x00f00f0000000000, 0xf00000f00000f00f), vec128_set2x(0x0000000000f00000, 0x00000f00f00f00f0), }, { vec128_set2x(0x0000ff00ff0000ff, 0xff00ffffff000000), vec128_set2x(0x0000ff000000ff00, 0xff0000ffff000000), vec128_set2x(0xff0000ff00ff0000, 0xffff00ffff000000), vec128_set2x(0xffff0000ff000000, 0xff00ffffffffff00), vec128_set2x(0x00ff00ff00ff0000, 0x00000000ff00ff00), vec128_set2x(0x0000ffffff000000, 0xffffffff00ff0000), vec128_set2x(0x00ffff00ff000000, 0x00ffffff00ff0000), vec128_set2x(0xffffff0000ff0000, 0xffff00ffff00ffff), vec128_set2x(0xffff00ffff00ff00, 0xffff0000ffffffff), vec128_set2x(0x0000ff0000000000, 0xff00000000ff0000), vec128_set2x(0xffffff00ff000000, 0x000000ff00ff00ff), vec128_set2x(0x00ff000000000000, 0x00ff00ff00ffff00), }, { vec128_set2x(0x000000000000ffff, 0x0000000000000000), vec128_set2x(0x00000000ffff0000, 0xffff000000000000), vec128_set2x(0x0000000000000000, 0x0000000000000000), vec128_set2x(0xffff000000000000, 0x0000000000000000), vec128_set2x(0x00000000ffff0000, 0xffff00000000ffff), vec128_set2x(0x0000ffff00000000, 0x0000000000000000), vec128_set2x(0x0000000000000000, 0x0000ffff00000000), vec128_set2x(0x00000000ffff0000, 0xffff00000000ffff), vec128_set2x(0x0000ffff00000000, 0x00000000ffff0000), vec128_set2x(0x0000000000000000, 0x0000000000000000), vec128_set2x(0x0000000000000000, 0xffff00000000ffff), vec128_set2x(0x0000000000000000, 0x00000000ffff0000), }, { vec128_set2x(0x00000000ffffffff, 0x0000000000000000), vec128_set2x(0xffffffff00000000, 0x0000000000000000), vec128_set2x(0xffffffff00000000, 0x00000000ffffffff), vec128_set2x(0x0000000000000000, 0xffffffff00000000), vec128_set2x(0x0000000000000000, 0xffffffff00000000), vec128_set2x(0xffffffff00000000, 0x0000000000000000), vec128_set2x(0x0000000000000000, 0xffffffff00000000), vec128_set2x(0x0000000000000000, 0xffffffffffffffff), vec128_set2x(0xffffffff00000000, 0xffffffff00000000), vec128_set2x(0x0000000000000000, 0x0000000000000000), vec128_set2x(0x0000000000000000, 0xffffffffffffffff), vec128_set2x(0x0000000000000000, 0xffffffff00000000), }, libmceliece-20230612/crypto_kem/348864/avx/shared-fft_consts.c0000644000000000000000000000033214441554467022234 0ustar rootroot// linker define fft_consts #include "fft_consts.h" #undef vec256_set4x #define vec256_set4x(a0,a1,a2,a3) {a0,a1,a2,a3} __attribute__((aligned(32))) const vec256 fft_consts[17][GFBITS] = { #include "consts.data" }; libmceliece-20230612/crypto_kem/348864/avx/shared-fft_powers.c0000644000000000000000000000033214441554467022242 0ustar rootroot// linker define fft_powers #include "fft_powers.h" #undef vec256_set4x #define vec256_set4x(a0,a1,a2,a3) {a0,a1,a2,a3} __attribute__((aligned(32))) const vec256 fft_powers[16][GFBITS] = { #include "powers.data" }; libmceliece-20230612/crypto_kem/348864/avx/shared-fft_scalars.c0000644000000000000000000000017514441554467022360 0ustar rootroot// linker define fft_scalars #include "fft_scalars.h" const uint64_t fft_scalars[5][GFBITS] = { #include "scalars.data" }; libmceliece-20230612/crypto_kem/348864/avx/shared-fft_scalars_2x.c0000644000000000000000000000033514441554467022767 0ustar rootroot// linker define fft_scalars_2x #include "fft_scalars_2x.h" #undef vec128_set2x #define vec128_set2x(a0,a1) {a0,a1} __attribute__((aligned(32))) const vec128 fft_scalars_2x[5][GFBITS] = { #include "scalars_2x.data" }; libmceliece-20230612/crypto_kem/348864/avx/sk_gen.c0000644000000000000000000000513714441554467020076 0ustar rootroot/* This file is for secret-key generation */ // 20221230 djb: add linker lines // linker define genpoly_gen // linker use gf_mul gf_inv // linker use vec_GF_mul // linker use vec_mul_asm // linker use transpose_64x64_asm #include "sk_gen.h" #include "randombytes.h" #include "controlbits.h" #include "transpose.h" #include "params.h" #include "util.h" #include "vec.h" #include "gf.h" #include "crypto_declassify.h" #include "crypto_uint16.h" static inline crypto_uint16 gf_is_zero_declassify(gf t) { crypto_uint16 mask = crypto_uint16_zero_mask(t); crypto_declassify(&mask,sizeof mask); return mask; } /* input: v, a list of GF(2^m) elements in bitsliced form */ /* input: idx, an index */ /* return: the idx-th element in v */ static inline gf extract_gf(vec v[GFBITS], int idx) { int i; gf ret; ret = 0; for (i = GFBITS-1; i >= 0; i--) { ret <<= 1; ret |= (v[i] >> idx) & 1; } return ret; } /* same as extract_gf but reduces return value to 1 bit */ static inline vec extract_bit(vec v[GFBITS], int idx) { int i; vec ret; ret = 0; for (i = GFBITS-1; i >= 0; i--) ret |= v[i]; return (ret >> idx) & 1; } /* input: f, element in GF((2^m)^t) */ /* output: out, minimal polynomial of f */ /* return: 0 for success and -1 for failure */ int genpoly_gen(gf *out, gf *f) { int i, j, k; gf t, inv; vec v[ GFBITS ], buf[ GFBITS ][ 64 ], mat[ 64 ][ GFBITS ], mask; // fill matrix buf[0][0] = 1; for (i = 1; i < GFBITS; i++) buf[i][0] = 0; for (j = 0; j < GFBITS; j++) for (i = SYS_T-1; i >= 0; i--) { v[j] <<= 1; v[j] |= (f[i] >> j) & 1; } for (i = 0; i < GFBITS; i++) buf[i][1] = v[i]; for (k = 2; k <= SYS_T; k++) { vec_GF_mul(v, v, f); if (k < SYS_T) { for (i = 0; i < GFBITS; i++) buf[i][k] = v[i]; } else { for (i = 0; i < SYS_T; i++) out[i] = extract_gf(v, i); } } for (i = 0; i < GFBITS; i++) transpose_64x64(buf[i]); for (j = 0; j < SYS_T; j++) for (i = 0; i < GFBITS; i++) mat[j][i] = buf[i][j]; // gaussian for (i = 0; i < SYS_T; i++) { for (j = i+1; j < SYS_T; j++) { mask = extract_bit(mat[i], i); mask -= 1; for (k = 0; k < GFBITS; k++) mat[i][k] ^= mat[j][k] & mask; out[i] ^= out[j] & mask; } // t = extract_gf(mat[i], i); if (gf_is_zero_declassify(t)) return -1; // return if not systematic // inv = gf_inv(t); vec_mul_gf(mat[i], mat[i], inv); out[i] = gf_mul(out[i], inv); for (j = 0; j < SYS_T; j++) { if (j != i) { t = extract_gf(mat[j], i); vec_mul_gf(v, mat[i], t); vec_add(mat[j], mat[j], v); out[j] ^= gf_mul(out[i], t); } } } return 0; } libmceliece-20230612/crypto_kem/348864/avx/sk_gen.h0000644000000000000000000000044414441554467020077 0ustar rootroot/* This file is for secret-key generation */ #ifndef SK_GEN_H #define SK_GEN_H #define genpoly_gen CRYPTO_NAMESPACE(genpoly_gen) #define perm_check CRYPTO_SHARED_NAMESPACE(perm_check) #include "gf.h" #include int genpoly_gen(gf *, gf *); int perm_check(uint32_t *); #endif libmceliece-20230612/crypto_kem/348864/avx/syndrome_asm.S0000644000000000000000000003316414441554467021311 0ustar rootroot// 20221231 djb: port hidden to macos; tnx thom wiggers // 20221230 djb: add linker line // linker define syndrome_asm #include "crypto_asm_hidden.h" #define syndrome_asm CRYPTO_SHARED_NAMESPACE(syndrome_asm) #define _syndrome_asm _CRYPTO_SHARED_NAMESPACE(syndrome_asm) # qhasm: int64 input_0 # qhasm: int64 input_1 # qhasm: int64 input_2 # qhasm: int64 input_3 # qhasm: int64 input_4 # qhasm: int64 input_5 # qhasm: stack64 input_6 # qhasm: stack64 input_7 # qhasm: int64 caller_r11 # qhasm: int64 caller_r12 # qhasm: int64 caller_r13 # qhasm: int64 caller_r14 # qhasm: int64 caller_r15 # qhasm: int64 caller_rbx # qhasm: int64 caller_rbp # qhasm: int64 b64 # qhasm: int64 synd # qhasm: int64 addr # qhasm: int64 c # qhasm: int64 c_all # qhasm: int64 row # qhasm: int64 p # qhasm: int64 e # qhasm: int64 s # qhasm: reg256 pp # qhasm: reg256 ee # qhasm: reg256 ss # qhasm: int64 buf_ptr # qhasm: stack256 buf # qhasm: enter syndrome_asm .p2align 5 ASM_HIDDEN _syndrome_asm ASM_HIDDEN syndrome_asm .global _syndrome_asm .global syndrome_asm _syndrome_asm: syndrome_asm: mov %rsp,%r11 and $31,%r11 add $32,%r11 sub %r11,%rsp # qhasm: input_1 += 260780 # asm 1: add $260780,buf_ptr=int64#4 # asm 2: leaq buf_ptr=%rcx leaq 0(%rsp),%rcx # qhasm: row = 768 # asm 1: mov $768,>row=int64#5 # asm 2: mov $768,>row=%r8 mov $768,%r8 # qhasm: loop: ._loop: # qhasm: row -= 1 # asm 1: sub $1,ss=reg256#1 # asm 2: vmovupd 0(ss=%ymm0 vmovupd 0(%rsi),%ymm0 # qhasm: ee = mem256[ input_2 + 96 ] # asm 1: vmovupd 96(ee=reg256#2 # asm 2: vmovupd 96(ee=%ymm1 vmovupd 96(%rdx),%ymm1 # qhasm: ss &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 32(pp=%ymm1 vmovupd 32(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 128 ] # asm 1: vmovupd 128(ee=reg256#3 # asm 2: vmovupd 128(ee=%ymm2 vmovupd 128(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 64(pp=%ymm1 vmovupd 64(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 160 ] # asm 1: vmovupd 160(ee=reg256#3 # asm 2: vmovupd 160(ee=%ymm2 vmovupd 160(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 96(pp=%ymm1 vmovupd 96(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 192 ] # asm 1: vmovupd 192(ee=reg256#3 # asm 2: vmovupd 192(ee=%ymm2 vmovupd 192(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 128(pp=%ymm1 vmovupd 128(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 224 ] # asm 1: vmovupd 224(ee=reg256#3 # asm 2: vmovupd 224(ee=%ymm2 vmovupd 224(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 160(pp=%ymm1 vmovupd 160(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 256 ] # asm 1: vmovupd 256(ee=reg256#3 # asm 2: vmovupd 256(ee=%ymm2 vmovupd 256(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 192(pp=%ymm1 vmovupd 192(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 288 ] # asm 1: vmovupd 288(ee=reg256#3 # asm 2: vmovupd 288(ee=%ymm2 vmovupd 288(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 224(pp=%ymm1 vmovupd 224(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 320 ] # asm 1: vmovupd 320(ee=reg256#3 # asm 2: vmovupd 320(ee=%ymm2 vmovupd 320(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 256(pp=%ymm1 vmovupd 256(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 352 ] # asm 1: vmovupd 352(ee=reg256#3 # asm 2: vmovupd 352(ee=%ymm2 vmovupd 352(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand pp=reg256#2 # asm 2: vmovupd 288(pp=%ymm1 vmovupd 288(%rsi),%ymm1 # qhasm: ee = mem256[ input_2 + 384 ] # asm 1: vmovupd 384(ee=reg256#3 # asm 2: vmovupd 384(ee=%ymm2 vmovupd 384(%rdx),%ymm2 # qhasm: pp &= ee # asm 1: vpand buf=stack256#1 # asm 2: vmovapd buf=0(%rsp) vmovapd %ymm0,0(%rsp) # qhasm: s = *(uint64 *)(input_1 + 320) # asm 1: movq 320(s=int64#6 # asm 2: movq 320(s=%r9 movq 320(%rsi),%r9 # qhasm: e = *(uint64 *)(input_2 + 416) # asm 1: movq 416(e=int64#7 # asm 2: movq 416(e=%rax movq 416(%rdx),%rax # qhasm: s &= e # asm 1: and p=int64#7 # asm 2: movq 328(p=%rax movq 328(%rsi),%rax # qhasm: e = *(uint64 *)(input_2 + 424) # asm 1: movq 424(e=int64#8 # asm 2: movq 424(e=%r10 movq 424(%rdx),%r10 # qhasm: p &= e # asm 1: and p=int64#7d # asm 2: movl 336(p=%eax movl 336(%rsi),%eax # qhasm: e = *(uint32 *)(input_2 + 432) # asm 1: movl 432(e=int64#8d # asm 2: movl 432(e=%r10d movl 432(%rdx),%r10d # qhasm: p &= e # asm 1: and c_all=int64#6 # asm 2: popcnt c_all=%r9 popcnt %r9, %r9 # qhasm: b64 = mem64[ buf_ptr + 0 ] # asm 1: movq 0(b64=int64#7 # asm 2: movq 0(b64=%rax movq 0(%rcx),%rax # qhasm: c = count(b64) # asm 1: popcnt c=int64#7 # asm 2: popcnt c=%rax popcnt %rax, %rax # qhasm: c_all ^= c # asm 1: xor b64=int64#7 # asm 2: movq 8(b64=%rax movq 8(%rcx),%rax # qhasm: c = count(b64) # asm 1: popcnt c=int64#7 # asm 2: popcnt c=%rax popcnt %rax, %rax # qhasm: c_all ^= c # asm 1: xor b64=int64#7 # asm 2: movq 16(b64=%rax movq 16(%rcx),%rax # qhasm: c = count(b64) # asm 1: popcnt c=int64#7 # asm 2: popcnt c=%rax popcnt %rax, %rax # qhasm: c_all ^= c # asm 1: xor b64=int64#7 # asm 2: movq 24(b64=%rax movq 24(%rcx),%rax # qhasm: c = count(b64) # asm 1: popcnt c=int64#7 # asm 2: popcnt c=%rax popcnt %rax, %rax # qhasm: c_all ^= c # asm 1: xor addr=int64#7 # asm 2: mov addr=%rax mov %r8,%rax # qhasm: (uint64) addr >>= 3 # asm 1: shr $3,synd=int64#8 # asm 2: movzbq 0(synd=%r10 movzbq 0(%rax),%r10 # qhasm: synd <<= 1 # asm 1: shl $1,ss=reg256#1 # asm 2: vmovupd 0(ss=%ymm0 vmovupd 0(%rdi),%ymm0 # qhasm: ee = mem256[ input_2 + 0 ] # asm 1: vmovupd 0(ee=reg256#2 # asm 2: vmovupd 0(ee=%ymm1 vmovupd 0(%rdx),%ymm1 # qhasm: ss ^= ee # asm 1: vpxor ss=reg256#1 # asm 2: vmovupd 32(ss=%ymm0 vmovupd 32(%rdi),%ymm0 # qhasm: ee = mem256[ input_2 + 32 ] # asm 1: vmovupd 32(ee=reg256#2 # asm 2: vmovupd 32(ee=%ymm1 vmovupd 32(%rdx),%ymm1 # qhasm: ss ^= ee # asm 1: vpxor ss=reg256#1 # asm 2: vmovupd 64(ss=%ymm0 vmovupd 64(%rdi),%ymm0 # qhasm: ee = mem256[ input_2 + 64 ] # asm 1: vmovupd 64(ee=reg256#2 # asm 2: vmovupd 64(ee=%ymm1 vmovupd 64(%rdx),%ymm1 # qhasm: ss ^= ee # asm 1: vpxor >= 3 addr += input_0 synd = *(uint8 *) (addr + 0) synd <<= 1 (uint32) c_all &= 1 synd |= c_all *(uint8 *) (addr + 0) = synd input_1 -= 340 =? row-0 goto loop if != ss = mem256[ input_0 + 0 ] ee = mem256[ input_2 + 0 ] ss ^= ee mem256[ input_0 + 0 ] = ss ss = mem256[ input_0 + 32 ] ee = mem256[ input_2 + 32 ] ss ^= ee mem256[ input_0 + 32 ] = ss ss = mem256[ input_0 + 64 ] ee = mem256[ input_2 + 64 ] ss ^= ee mem256[ input_0 + 64 ] = ss return libmceliece-20230612/crypto_kem/348864/avx/transpose.h0000644000000000000000000000117114441554467020645 0ustar rootroot/* This file is for matrix transposition */ #ifndef TRANSPOSE_H #define TRANSPOSE_H #define transpose_64x128_sp_asm CRYPTO_SHARED_NAMESPACE(transpose_64x128_sp_asm) #define transpose_64x256_sp_asm CRYPTO_SHARED_NAMESPACE(transpose_64x256_sp_asm) #define transpose_64x64_asm CRYPTO_SHARED_NAMESPACE(transpose_64x64_asm) #include "vec256.h" #include extern void transpose_64x64_asm(uint64_t *); static inline void transpose_64x64(uint64_t *in) { transpose_64x64_asm(in); } extern void transpose_64x256_sp_asm(vec256 *); static inline void transpose_64x256_sp(vec256 *in) { transpose_64x256_sp_asm(in); } #endif libmceliece-20230612/crypto_kem/348864/avx/transpose_64x256_sp_asm.S0000644000000000000000000076646214441554467023145 0ustar rootroot// 20221231 djb: port hidden to macos; tnx thom wiggers // 20221230 djb: add linker lines // linker define transpose_64x256_sp_asm // linker use MASK0_0 MASK1_0 MASK2_0 MASK3_0 MASK4_0 MASK5_0 // linker use MASK0_1 MASK1_1 MASK2_1 MASK3_1 MASK4_1 MASK5_1 #include "crypto_asm_hidden.h" #define MASK0_0 CRYPTO_SHARED_NAMESPACE(MASK0_0) #define _MASK0_0 _CRYPTO_SHARED_NAMESPACE(MASK0_0) #define MASK0_1 CRYPTO_SHARED_NAMESPACE(MASK0_1) #define _MASK0_1 _CRYPTO_SHARED_NAMESPACE(MASK0_1) #define MASK1_0 CRYPTO_SHARED_NAMESPACE(MASK1_0) #define _MASK1_0 _CRYPTO_SHARED_NAMESPACE(MASK1_0) #define MASK1_1 CRYPTO_SHARED_NAMESPACE(MASK1_1) #define _MASK1_1 _CRYPTO_SHARED_NAMESPACE(MASK1_1) #define MASK2_0 CRYPTO_SHARED_NAMESPACE(MASK2_0) #define _MASK2_0 _CRYPTO_SHARED_NAMESPACE(MASK2_0) #define MASK2_1 CRYPTO_SHARED_NAMESPACE(MASK2_1) #define _MASK2_1 _CRYPTO_SHARED_NAMESPACE(MASK2_1) #define MASK3_0 CRYPTO_SHARED_NAMESPACE(MASK3_0) #define _MASK3_0 _CRYPTO_SHARED_NAMESPACE(MASK3_0) #define MASK3_1 CRYPTO_SHARED_NAMESPACE(MASK3_1) #define _MASK3_1 _CRYPTO_SHARED_NAMESPACE(MASK3_1) #define MASK4_0 CRYPTO_SHARED_NAMESPACE(MASK4_0) #define _MASK4_0 _CRYPTO_SHARED_NAMESPACE(MASK4_0) #define MASK4_1 CRYPTO_SHARED_NAMESPACE(MASK4_1) #define _MASK4_1 _CRYPTO_SHARED_NAMESPACE(MASK4_1) #define MASK5_0 CRYPTO_SHARED_NAMESPACE(MASK5_0) #define _MASK5_0 _CRYPTO_SHARED_NAMESPACE(MASK5_0) #define MASK5_1 CRYPTO_SHARED_NAMESPACE(MASK5_1) #define _MASK5_1 _CRYPTO_SHARED_NAMESPACE(MASK5_1) #define transpose_64x256_sp_asm CRYPTO_SHARED_NAMESPACE(transpose_64x256_sp_asm) #define _transpose_64x256_sp_asm _CRYPTO_SHARED_NAMESPACE(transpose_64x256_sp_asm) # qhasm: int64 input_0 # qhasm: int64 input_1 # qhasm: int64 input_2 # qhasm: int64 input_3 # qhasm: int64 input_4 # qhasm: int64 input_5 # qhasm: stack64 input_6 # qhasm: stack64 input_7 # qhasm: int64 caller_r11 # qhasm: int64 caller_r12 # qhasm: int64 caller_r13 # qhasm: int64 caller_r14 # qhasm: int64 caller_r15 # qhasm: int64 caller_rbx # qhasm: int64 caller_rbp # qhasm: reg256 x0 # qhasm: reg256 x1 # qhasm: reg256 x2 # qhasm: reg256 x3 # qhasm: reg256 x4 # qhasm: reg256 x5 # qhasm: reg256 x6 # qhasm: reg256 x7 # qhasm: reg256 t0 # qhasm: reg256 t1 # qhasm: reg256 v00 # qhasm: reg256 v01 # qhasm: reg256 v10 # qhasm: reg256 v11 # qhasm: reg256 mask0 # qhasm: reg256 mask1 # qhasm: reg256 mask2 # qhasm: reg256 mask3 # qhasm: reg256 mask4 # qhasm: reg256 mask5 # qhasm: enter transpose_64x256_sp_asm .p2align 5 ASM_HIDDEN _transpose_64x256_sp_asm ASM_HIDDEN transpose_64x256_sp_asm .global _transpose_64x256_sp_asm .global transpose_64x256_sp_asm _transpose_64x256_sp_asm: transpose_64x256_sp_asm: mov %rsp,%r11 and $31,%r11 add $0,%r11 sub %r11,%rsp # qhasm: mask0 aligned= mem256[ MASK5_0 ] # asm 1: vmovapd MASK5_0(%rip),>mask0=reg256#1 # asm 2: vmovapd MASK5_0(%rip),>mask0=%ymm0 vmovapd MASK5_0(%rip),%ymm0 # qhasm: mask1 aligned= mem256[ MASK5_1 ] # asm 1: vmovapd MASK5_1(%rip),>mask1=reg256#2 # asm 2: vmovapd MASK5_1(%rip),>mask1=%ymm1 vmovapd MASK5_1(%rip),%ymm1 # qhasm: mask2 aligned= mem256[ MASK4_0 ] # asm 1: vmovapd MASK4_0(%rip),>mask2=reg256#3 # asm 2: vmovapd MASK4_0(%rip),>mask2=%ymm2 vmovapd MASK4_0(%rip),%ymm2 # qhasm: mask3 aligned= mem256[ MASK4_1 ] # asm 1: vmovapd MASK4_1(%rip),>mask3=reg256#4 # asm 2: vmovapd MASK4_1(%rip),>mask3=%ymm3 vmovapd MASK4_1(%rip),%ymm3 # qhasm: mask4 aligned= mem256[ MASK3_0 ] # asm 1: vmovapd MASK3_0(%rip),>mask4=reg256#5 # asm 2: vmovapd MASK3_0(%rip),>mask4=%ymm4 vmovapd MASK3_0(%rip),%ymm4 # qhasm: mask5 aligned= mem256[ MASK3_1 ] # asm 1: vmovapd MASK3_1(%rip),>mask5=reg256#6 # asm 2: vmovapd MASK3_1(%rip),>mask5=%ymm5 vmovapd MASK3_1(%rip),%ymm5 # qhasm: x0 = mem256[ input_0 + 0 ] # asm 1: vmovupd 0(x0=reg256#7 # asm 2: vmovupd 0(x0=%ymm6 vmovupd 0(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 256 ] # asm 1: vmovupd 256(x1=reg256#8 # asm 2: vmovupd 256(x1=%ymm7 vmovupd 256(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 512 ] # asm 1: vmovupd 512(x2=reg256#9 # asm 2: vmovupd 512(x2=%ymm8 vmovupd 512(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 768 ] # asm 1: vmovupd 768(x3=reg256#10 # asm 2: vmovupd 768(x3=%ymm9 vmovupd 768(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1024 ] # asm 1: vmovupd 1024(x4=reg256#11 # asm 2: vmovupd 1024(x4=%ymm10 vmovupd 1024(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1280 ] # asm 1: vmovupd 1280(x5=reg256#12 # asm 2: vmovupd 1280(x5=%ymm11 vmovupd 1280(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1536 ] # asm 1: vmovupd 1536(x6=reg256#13 # asm 2: vmovupd 1536(x6=%ymm12 vmovupd 1536(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1792 ] # asm 1: vmovupd 1792(x7=reg256#14 # asm 2: vmovupd 1792(x7=%ymm13 vmovupd 1792(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm13,%ymm15 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm11,%ymm15 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#15 # asm 2: vpsrld $16,v01=%ymm14 vpsrld $16,%ymm14,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm12,%ymm15 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm8,%ymm15 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm9,%ymm15 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm14,%ymm15 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#14 # asm 2: vpsrlw $8,v01=%ymm13 vpsrlw $8,%ymm13,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm10,%ymm15 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm8,%ymm15 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#13 # asm 2: vpsrlw $8,v01=%ymm12 vpsrlw $8,%ymm12,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm7,%ymm15 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 0 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 32(x0=%ymm6 vmovupd 32(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 288 ] # asm 1: vmovupd 288(x1=reg256#8 # asm 2: vmovupd 288(x1=%ymm7 vmovupd 288(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 544 ] # asm 1: vmovupd 544(x2=reg256#9 # asm 2: vmovupd 544(x2=%ymm8 vmovupd 544(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 800 ] # asm 1: vmovupd 800(x3=reg256#10 # asm 2: vmovupd 800(x3=%ymm9 vmovupd 800(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1056 ] # asm 1: vmovupd 1056(x4=reg256#11 # asm 2: vmovupd 1056(x4=%ymm10 vmovupd 1056(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1312 ] # asm 1: vmovupd 1312(x5=reg256#12 # asm 2: vmovupd 1312(x5=%ymm11 vmovupd 1312(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1568 ] # asm 1: vmovupd 1568(x6=reg256#13 # asm 2: vmovupd 1568(x6=%ymm12 vmovupd 1568(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1824 ] # asm 1: vmovupd 1824(x7=reg256#14 # asm 2: vmovupd 1824(x7=%ymm13 vmovupd 1824(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm13,%ymm15 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm11,%ymm15 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#15 # asm 2: vpsrld $16,v01=%ymm14 vpsrld $16,%ymm14,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm12,%ymm15 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm8,%ymm15 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm9,%ymm15 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm14,%ymm15 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#14 # asm 2: vpsrlw $8,v01=%ymm13 vpsrlw $8,%ymm13,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm10,%ymm15 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm8,%ymm15 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#13 # asm 2: vpsrlw $8,v01=%ymm12 vpsrlw $8,%ymm12,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm7,%ymm15 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 32 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 64(x0=%ymm6 vmovupd 64(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 320 ] # asm 1: vmovupd 320(x1=reg256#8 # asm 2: vmovupd 320(x1=%ymm7 vmovupd 320(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 576 ] # asm 1: vmovupd 576(x2=reg256#9 # asm 2: vmovupd 576(x2=%ymm8 vmovupd 576(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 832 ] # asm 1: vmovupd 832(x3=reg256#10 # asm 2: vmovupd 832(x3=%ymm9 vmovupd 832(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1088 ] # asm 1: vmovupd 1088(x4=reg256#11 # asm 2: vmovupd 1088(x4=%ymm10 vmovupd 1088(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1344 ] # asm 1: vmovupd 1344(x5=reg256#12 # asm 2: vmovupd 1344(x5=%ymm11 vmovupd 1344(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1600 ] # asm 1: vmovupd 1600(x6=reg256#13 # asm 2: vmovupd 1600(x6=%ymm12 vmovupd 1600(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1856 ] # asm 1: vmovupd 1856(x7=reg256#14 # asm 2: vmovupd 1856(x7=%ymm13 vmovupd 1856(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm13,%ymm15 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm11,%ymm15 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#15 # asm 2: vpsrld $16,v01=%ymm14 vpsrld $16,%ymm14,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm12,%ymm15 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm8,%ymm15 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm9,%ymm15 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm14,%ymm15 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#14 # asm 2: vpsrlw $8,v01=%ymm13 vpsrlw $8,%ymm13,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm10,%ymm15 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm8,%ymm15 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#13 # asm 2: vpsrlw $8,v01=%ymm12 vpsrlw $8,%ymm12,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm7,%ymm15 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 64 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 96(x0=%ymm6 vmovupd 96(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 352 ] # asm 1: vmovupd 352(x1=reg256#8 # asm 2: vmovupd 352(x1=%ymm7 vmovupd 352(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 608 ] # asm 1: vmovupd 608(x2=reg256#9 # asm 2: vmovupd 608(x2=%ymm8 vmovupd 608(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 864 ] # asm 1: vmovupd 864(x3=reg256#10 # asm 2: vmovupd 864(x3=%ymm9 vmovupd 864(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1120 ] # asm 1: vmovupd 1120(x4=reg256#11 # asm 2: vmovupd 1120(x4=%ymm10 vmovupd 1120(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1376 ] # asm 1: vmovupd 1376(x5=reg256#12 # asm 2: vmovupd 1376(x5=%ymm11 vmovupd 1376(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1632 ] # asm 1: vmovupd 1632(x6=reg256#13 # asm 2: vmovupd 1632(x6=%ymm12 vmovupd 1632(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1888 ] # asm 1: vmovupd 1888(x7=reg256#14 # asm 2: vmovupd 1888(x7=%ymm13 vmovupd 1888(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm13,%ymm15 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm11,%ymm15 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#15 # asm 2: vpsrld $16,v01=%ymm14 vpsrld $16,%ymm14,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm12,%ymm15 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm8,%ymm15 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm9,%ymm15 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm14,%ymm15 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#14 # asm 2: vpsrlw $8,v01=%ymm13 vpsrlw $8,%ymm13,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm10,%ymm15 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm8,%ymm15 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#13 # asm 2: vpsrlw $8,v01=%ymm12 vpsrlw $8,%ymm12,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm7,%ymm15 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 96 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 128(x0=%ymm6 vmovupd 128(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 384 ] # asm 1: vmovupd 384(x1=reg256#8 # asm 2: vmovupd 384(x1=%ymm7 vmovupd 384(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 640 ] # asm 1: vmovupd 640(x2=reg256#9 # asm 2: vmovupd 640(x2=%ymm8 vmovupd 640(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 896 ] # asm 1: vmovupd 896(x3=reg256#10 # asm 2: vmovupd 896(x3=%ymm9 vmovupd 896(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1152 ] # asm 1: vmovupd 1152(x4=reg256#11 # asm 2: vmovupd 1152(x4=%ymm10 vmovupd 1152(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1408 ] # asm 1: vmovupd 1408(x5=reg256#12 # asm 2: vmovupd 1408(x5=%ymm11 vmovupd 1408(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1664 ] # asm 1: vmovupd 1664(x6=reg256#13 # asm 2: vmovupd 1664(x6=%ymm12 vmovupd 1664(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1920 ] # asm 1: vmovupd 1920(x7=reg256#14 # asm 2: vmovupd 1920(x7=%ymm13 vmovupd 1920(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm13,%ymm15 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm11,%ymm15 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#15 # asm 2: vpsrld $16,v01=%ymm14 vpsrld $16,%ymm14,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm12,%ymm15 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm8,%ymm15 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm9,%ymm15 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm14,%ymm15 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#14 # asm 2: vpsrlw $8,v01=%ymm13 vpsrlw $8,%ymm13,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm10,%ymm15 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm8,%ymm15 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#13 # asm 2: vpsrlw $8,v01=%ymm12 vpsrlw $8,%ymm12,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm7,%ymm15 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 128 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 160(x0=%ymm6 vmovupd 160(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 416 ] # asm 1: vmovupd 416(x1=reg256#8 # asm 2: vmovupd 416(x1=%ymm7 vmovupd 416(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 672 ] # asm 1: vmovupd 672(x2=reg256#9 # asm 2: vmovupd 672(x2=%ymm8 vmovupd 672(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 928 ] # asm 1: vmovupd 928(x3=reg256#10 # asm 2: vmovupd 928(x3=%ymm9 vmovupd 928(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1184 ] # asm 1: vmovupd 1184(x4=reg256#11 # asm 2: vmovupd 1184(x4=%ymm10 vmovupd 1184(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1440 ] # asm 1: vmovupd 1440(x5=reg256#12 # asm 2: vmovupd 1440(x5=%ymm11 vmovupd 1440(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1696 ] # asm 1: vmovupd 1696(x6=reg256#13 # asm 2: vmovupd 1696(x6=%ymm12 vmovupd 1696(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1952 ] # asm 1: vmovupd 1952(x7=reg256#14 # asm 2: vmovupd 1952(x7=%ymm13 vmovupd 1952(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm13,%ymm15 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm11,%ymm15 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#15 # asm 2: vpsrld $16,v01=%ymm14 vpsrld $16,%ymm14,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm12,%ymm15 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm8,%ymm15 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm9,%ymm15 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm14,%ymm15 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#14 # asm 2: vpsrlw $8,v01=%ymm13 vpsrlw $8,%ymm13,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm10,%ymm15 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm8,%ymm15 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#13 # asm 2: vpsrlw $8,v01=%ymm12 vpsrlw $8,%ymm12,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm7,%ymm15 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 160 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 192(x0=%ymm6 vmovupd 192(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 448 ] # asm 1: vmovupd 448(x1=reg256#8 # asm 2: vmovupd 448(x1=%ymm7 vmovupd 448(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 704 ] # asm 1: vmovupd 704(x2=reg256#9 # asm 2: vmovupd 704(x2=%ymm8 vmovupd 704(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 960 ] # asm 1: vmovupd 960(x3=reg256#10 # asm 2: vmovupd 960(x3=%ymm9 vmovupd 960(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1216 ] # asm 1: vmovupd 1216(x4=reg256#11 # asm 2: vmovupd 1216(x4=%ymm10 vmovupd 1216(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1472 ] # asm 1: vmovupd 1472(x5=reg256#12 # asm 2: vmovupd 1472(x5=%ymm11 vmovupd 1472(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1728 ] # asm 1: vmovupd 1728(x6=reg256#13 # asm 2: vmovupd 1728(x6=%ymm12 vmovupd 1728(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1984 ] # asm 1: vmovupd 1984(x7=reg256#14 # asm 2: vmovupd 1984(x7=%ymm13 vmovupd 1984(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm13,%ymm15 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm11,%ymm15 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#15 # asm 2: vpsrld $16,v01=%ymm14 vpsrld $16,%ymm14,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm12,%ymm15 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm8,%ymm15 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#16 # asm 2: vpslld $16,v10=%ymm15 vpslld $16,%ymm9,%ymm15 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm14,%ymm15 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#14 # asm 2: vpsrlw $8,v01=%ymm13 vpsrlw $8,%ymm13,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm10,%ymm15 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm8,%ymm15 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#13 # asm 2: vpsrlw $8,v01=%ymm12 vpsrlw $8,%ymm12,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#16 # asm 2: vpsllw $8,v10=%ymm15 vpsllw $8,%ymm7,%ymm15 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 192 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 224(x0=%ymm6 vmovupd 224(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 480 ] # asm 1: vmovupd 480(x1=reg256#8 # asm 2: vmovupd 480(x1=%ymm7 vmovupd 480(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 736 ] # asm 1: vmovupd 736(x2=reg256#9 # asm 2: vmovupd 736(x2=%ymm8 vmovupd 736(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 992 ] # asm 1: vmovupd 992(x3=reg256#10 # asm 2: vmovupd 992(x3=%ymm9 vmovupd 992(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1248 ] # asm 1: vmovupd 1248(x4=reg256#11 # asm 2: vmovupd 1248(x4=%ymm10 vmovupd 1248(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1504 ] # asm 1: vmovupd 1504(x5=reg256#12 # asm 2: vmovupd 1504(x5=%ymm11 vmovupd 1504(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1760 ] # asm 1: vmovupd 1760(x6=reg256#13 # asm 2: vmovupd 1760(x6=%ymm12 vmovupd 1760(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 2016 ] # asm 1: vmovupd 2016(x7=reg256#14 # asm 2: vmovupd 2016(x7=%ymm13 vmovupd 2016(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: 4x v10 = x4 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm10,%ymm15 # qhasm: 4x v01 = x0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#7 # asm 2: vpsrlq $32,v01=%ymm6 vpsrlq $32,%ymm6,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: 4x v10 = x5 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm11,%ymm15 # qhasm: 4x v01 = x1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#8 # asm 2: vpsrlq $32,v01=%ymm7 vpsrlq $32,%ymm7,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: 4x v10 = x6 << 32 # asm 1: vpsllq $32,v10=reg256#16 # asm 2: vpsllq $32,v10=%ymm15 vpsllq $32,%ymm12,%ymm15 # qhasm: 4x v01 = x2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#9 # asm 2: vpsrlq $32,v01=%ymm8 vpsrlq $32,%ymm8,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#1 # asm 2: vpand v00=%ymm0 vpand %ymm9,%ymm0,%ymm0 # qhasm: 4x v10 = x7 << 32 # asm 1: vpsllq $32,v10=reg256#13 # asm 2: vpsllq $32,v10=%ymm12 vpsllq $32,%ymm13,%ymm12 # qhasm: 4x v01 = x3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg256#10 # asm 2: vpsrlq $32,v01=%ymm9 vpsrlq $32,%ymm9,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#2 # asm 2: vpand v11=%ymm1 vpand %ymm13,%ymm1,%ymm1 # qhasm: x3 = v00 | v10 # asm 1: vpor x3=reg256#1 # asm 2: vpor x3=%ymm0 vpor %ymm0,%ymm12,%ymm0 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#2 # asm 2: vpor x7=%ymm1 vpor %ymm9,%ymm1,%ymm1 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm14,%ymm2,%ymm9 # qhasm: 8x v10 = x2 << 16 # asm 1: vpslld $16,v10=reg256#13 # asm 2: vpslld $16,v10=%ymm12 vpslld $16,%ymm11,%ymm12 # qhasm: 8x v01 = x0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#14 # asm 2: vpsrld $16,v01=%ymm13 vpsrld $16,%ymm14,%ymm13 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm12,%ymm9 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm13,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm10,%ymm2,%ymm12 # qhasm: 8x v10 = x3 << 16 # asm 1: vpslld $16,v10=reg256#14 # asm 2: vpslld $16,v10=%ymm13 vpslld $16,%ymm0,%ymm13 # qhasm: 8x v01 = x1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#11 # asm 2: vpsrld $16,v01=%ymm10 vpsrld $16,%ymm10,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#1 # asm 2: vpand v11=%ymm0 vpand %ymm0,%ymm3,%ymm0 # qhasm: x1 = v00 | v10 # asm 1: vpor x1=reg256#13 # asm 2: vpor x1=%ymm12 vpor %ymm12,%ymm13,%ymm12 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#1 # asm 2: vpor x3=%ymm0 vpor %ymm10,%ymm0,%ymm0 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm6,%ymm2,%ymm10 # qhasm: 8x v10 = x6 << 16 # asm 1: vpslld $16,v10=reg256#14 # asm 2: vpslld $16,v10=%ymm13 vpslld $16,%ymm8,%ymm13 # qhasm: 8x v01 = x4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#7 # asm 2: vpsrld $16,v01=%ymm6 vpsrld $16,%ymm6,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#11 # asm 2: vpor x4=%ymm10 vpor %ymm10,%ymm13,%ymm10 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#3 # asm 2: vpand v00=%ymm2 vpand %ymm7,%ymm2,%ymm2 # qhasm: 8x v10 = x7 << 16 # asm 1: vpslld $16,v10=reg256#9 # asm 2: vpslld $16,v10=%ymm8 vpslld $16,%ymm1,%ymm8 # qhasm: 8x v01 = x5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg256#8 # asm 2: vpsrld $16,v01=%ymm7 vpsrld $16,%ymm7,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#2 # asm 2: vpand v11=%ymm1 vpand %ymm1,%ymm3,%ymm1 # qhasm: x5 = v00 | v10 # asm 1: vpor x5=reg256#3 # asm 2: vpor x5=%ymm2 vpor %ymm2,%ymm8,%ymm2 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#2 # asm 2: vpor x7=%ymm1 vpor %ymm7,%ymm1,%ymm1 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#4 # asm 2: vpand v00=%ymm3 vpand %ymm9,%ymm4,%ymm3 # qhasm: 16x v10 = x1 << 8 # asm 1: vpsllw $8,v10=reg256#8 # asm 2: vpsllw $8,v10=%ymm7 vpsllw $8,%ymm12,%ymm7 # qhasm: 16x v01 = x0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#9 # asm 2: vpsrlw $8,v01=%ymm8 vpsrlw $8,%ymm9,%ymm8 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm12,%ymm5,%ymm9 # qhasm: x0 = v00 | v10 # asm 1: vpor x0=reg256#4 # asm 2: vpor x0=%ymm3 vpor %ymm3,%ymm7,%ymm3 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#8 # asm 2: vpor x1=%ymm7 vpor %ymm8,%ymm9,%ymm7 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm11,%ymm4,%ymm8 # qhasm: 16x v10 = x3 << 8 # asm 1: vpsllw $8,v10=reg256#10 # asm 2: vpsllw $8,v10=%ymm9 vpsllw $8,%ymm0,%ymm9 # qhasm: 16x v01 = x2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#12 # asm 2: vpsrlw $8,v01=%ymm11 vpsrlw $8,%ymm11,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#1 # asm 2: vpand v11=%ymm0 vpand %ymm0,%ymm5,%ymm0 # qhasm: x2 = v00 | v10 # asm 1: vpor x2=reg256#9 # asm 2: vpor x2=%ymm8 vpor %ymm8,%ymm9,%ymm8 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#1 # asm 2: vpor x3=%ymm0 vpor %ymm11,%ymm0,%ymm0 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm10,%ymm4,%ymm9 # qhasm: 16x v10 = x5 << 8 # asm 1: vpsllw $8,v10=reg256#12 # asm 2: vpsllw $8,v10=%ymm11 vpsllw $8,%ymm2,%ymm11 # qhasm: 16x v01 = x4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#11 # asm 2: vpsrlw $8,v01=%ymm10 vpsrlw $8,%ymm10,%ymm10 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#3 # asm 2: vpand v11=%ymm2 vpand %ymm2,%ymm5,%ymm2 # qhasm: x4 = v00 | v10 # asm 1: vpor x4=reg256#10 # asm 2: vpor x4=%ymm9 vpor %ymm9,%ymm11,%ymm9 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#3 # asm 2: vpor x5=%ymm2 vpor %ymm10,%ymm2,%ymm2 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#5 # asm 2: vpand v00=%ymm4 vpand %ymm6,%ymm4,%ymm4 # qhasm: 16x v10 = x7 << 8 # asm 1: vpsllw $8,v10=reg256#11 # asm 2: vpsllw $8,v10=%ymm10 vpsllw $8,%ymm1,%ymm10 # qhasm: 16x v01 = x6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg256#7 # asm 2: vpsrlw $8,v01=%ymm6 vpsrlw $8,%ymm6,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#2 # asm 2: vpand v11=%ymm1 vpand %ymm1,%ymm5,%ymm1 # qhasm: x6 = v00 | v10 # asm 1: vpor x6=reg256#5 # asm 2: vpor x6=%ymm4 vpor %ymm4,%ymm10,%ymm4 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#2 # asm 2: vpor x7=%ymm1 vpor %ymm6,%ymm1,%ymm1 # qhasm: mem256[ input_0 + 224 ] = x0 # asm 1: vmovupd mask0=reg256#1 # asm 2: vmovapd MASK2_0(%rip),>mask0=%ymm0 vmovapd MASK2_0(%rip),%ymm0 # qhasm: mask1 aligned= mem256[ MASK2_1 ] # asm 1: vmovapd MASK2_1(%rip),>mask1=reg256#2 # asm 2: vmovapd MASK2_1(%rip),>mask1=%ymm1 vmovapd MASK2_1(%rip),%ymm1 # qhasm: mask2 aligned= mem256[ MASK1_0 ] # asm 1: vmovapd MASK1_0(%rip),>mask2=reg256#3 # asm 2: vmovapd MASK1_0(%rip),>mask2=%ymm2 vmovapd MASK1_0(%rip),%ymm2 # qhasm: mask3 aligned= mem256[ MASK1_1 ] # asm 1: vmovapd MASK1_1(%rip),>mask3=reg256#4 # asm 2: vmovapd MASK1_1(%rip),>mask3=%ymm3 vmovapd MASK1_1(%rip),%ymm3 # qhasm: mask4 aligned= mem256[ MASK0_0 ] # asm 1: vmovapd MASK0_0(%rip),>mask4=reg256#5 # asm 2: vmovapd MASK0_0(%rip),>mask4=%ymm4 vmovapd MASK0_0(%rip),%ymm4 # qhasm: mask5 aligned= mem256[ MASK0_1 ] # asm 1: vmovapd MASK0_1(%rip),>mask5=reg256#6 # asm 2: vmovapd MASK0_1(%rip),>mask5=%ymm5 vmovapd MASK0_1(%rip),%ymm5 # qhasm: x0 = mem256[ input_0 + 0 ] # asm 1: vmovupd 0(x0=reg256#7 # asm 2: vmovupd 0(x0=%ymm6 vmovupd 0(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 32 ] # asm 1: vmovupd 32(x1=reg256#8 # asm 2: vmovupd 32(x1=%ymm7 vmovupd 32(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 64 ] # asm 1: vmovupd 64(x2=reg256#9 # asm 2: vmovupd 64(x2=%ymm8 vmovupd 64(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 96 ] # asm 1: vmovupd 96(x3=reg256#10 # asm 2: vmovupd 96(x3=%ymm9 vmovupd 96(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 128 ] # asm 1: vmovupd 128(x4=reg256#11 # asm 2: vmovupd 128(x4=%ymm10 vmovupd 128(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 160 ] # asm 1: vmovupd 160(x5=reg256#12 # asm 2: vmovupd 160(x5=%ymm11 vmovupd 160(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 192 ] # asm 1: vmovupd 192(x6=reg256#13 # asm 2: vmovupd 192(x6=%ymm12 vmovupd 192(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 224 ] # asm 1: vmovupd 224(x7=reg256#14 # asm 2: vmovupd 224(x7=%ymm13 vmovupd 224(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm13,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#15 # asm 2: vpand v01=%ymm14 vpand %ymm14,%ymm3,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm9,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm14,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm13,%ymm5,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#13 # asm 2: vpand v01=%ymm12 vpand %ymm12,%ymm5,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm7,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 0 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 256(x0=%ymm6 vmovupd 256(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 288 ] # asm 1: vmovupd 288(x1=reg256#8 # asm 2: vmovupd 288(x1=%ymm7 vmovupd 288(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 320 ] # asm 1: vmovupd 320(x2=reg256#9 # asm 2: vmovupd 320(x2=%ymm8 vmovupd 320(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 352 ] # asm 1: vmovupd 352(x3=reg256#10 # asm 2: vmovupd 352(x3=%ymm9 vmovupd 352(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 384 ] # asm 1: vmovupd 384(x4=reg256#11 # asm 2: vmovupd 384(x4=%ymm10 vmovupd 384(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 416 ] # asm 1: vmovupd 416(x5=reg256#12 # asm 2: vmovupd 416(x5=%ymm11 vmovupd 416(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 448 ] # asm 1: vmovupd 448(x6=reg256#13 # asm 2: vmovupd 448(x6=%ymm12 vmovupd 448(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 480 ] # asm 1: vmovupd 480(x7=reg256#14 # asm 2: vmovupd 480(x7=%ymm13 vmovupd 480(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm13,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#15 # asm 2: vpand v01=%ymm14 vpand %ymm14,%ymm3,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm9,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm14,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm13,%ymm5,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#13 # asm 2: vpand v01=%ymm12 vpand %ymm12,%ymm5,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm7,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 256 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 512(x0=%ymm6 vmovupd 512(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 544 ] # asm 1: vmovupd 544(x1=reg256#8 # asm 2: vmovupd 544(x1=%ymm7 vmovupd 544(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 576 ] # asm 1: vmovupd 576(x2=reg256#9 # asm 2: vmovupd 576(x2=%ymm8 vmovupd 576(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 608 ] # asm 1: vmovupd 608(x3=reg256#10 # asm 2: vmovupd 608(x3=%ymm9 vmovupd 608(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 640 ] # asm 1: vmovupd 640(x4=reg256#11 # asm 2: vmovupd 640(x4=%ymm10 vmovupd 640(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 672 ] # asm 1: vmovupd 672(x5=reg256#12 # asm 2: vmovupd 672(x5=%ymm11 vmovupd 672(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 704 ] # asm 1: vmovupd 704(x6=reg256#13 # asm 2: vmovupd 704(x6=%ymm12 vmovupd 704(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 736 ] # asm 1: vmovupd 736(x7=reg256#14 # asm 2: vmovupd 736(x7=%ymm13 vmovupd 736(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm13,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#15 # asm 2: vpand v01=%ymm14 vpand %ymm14,%ymm3,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm9,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm14,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm13,%ymm5,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#13 # asm 2: vpand v01=%ymm12 vpand %ymm12,%ymm5,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm7,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 512 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 768(x0=%ymm6 vmovupd 768(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 800 ] # asm 1: vmovupd 800(x1=reg256#8 # asm 2: vmovupd 800(x1=%ymm7 vmovupd 800(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 832 ] # asm 1: vmovupd 832(x2=reg256#9 # asm 2: vmovupd 832(x2=%ymm8 vmovupd 832(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 864 ] # asm 1: vmovupd 864(x3=reg256#10 # asm 2: vmovupd 864(x3=%ymm9 vmovupd 864(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 896 ] # asm 1: vmovupd 896(x4=reg256#11 # asm 2: vmovupd 896(x4=%ymm10 vmovupd 896(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 928 ] # asm 1: vmovupd 928(x5=reg256#12 # asm 2: vmovupd 928(x5=%ymm11 vmovupd 928(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 960 ] # asm 1: vmovupd 960(x6=reg256#13 # asm 2: vmovupd 960(x6=%ymm12 vmovupd 960(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 992 ] # asm 1: vmovupd 992(x7=reg256#14 # asm 2: vmovupd 992(x7=%ymm13 vmovupd 992(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm13,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#15 # asm 2: vpand v01=%ymm14 vpand %ymm14,%ymm3,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm9,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm14,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm13,%ymm5,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#13 # asm 2: vpand v01=%ymm12 vpand %ymm12,%ymm5,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm7,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 768 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 1024(x0=%ymm6 vmovupd 1024(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 1056 ] # asm 1: vmovupd 1056(x1=reg256#8 # asm 2: vmovupd 1056(x1=%ymm7 vmovupd 1056(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 1088 ] # asm 1: vmovupd 1088(x2=reg256#9 # asm 2: vmovupd 1088(x2=%ymm8 vmovupd 1088(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 1120 ] # asm 1: vmovupd 1120(x3=reg256#10 # asm 2: vmovupd 1120(x3=%ymm9 vmovupd 1120(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1152 ] # asm 1: vmovupd 1152(x4=reg256#11 # asm 2: vmovupd 1152(x4=%ymm10 vmovupd 1152(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1184 ] # asm 1: vmovupd 1184(x5=reg256#12 # asm 2: vmovupd 1184(x5=%ymm11 vmovupd 1184(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1216 ] # asm 1: vmovupd 1216(x6=reg256#13 # asm 2: vmovupd 1216(x6=%ymm12 vmovupd 1216(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1248 ] # asm 1: vmovupd 1248(x7=reg256#14 # asm 2: vmovupd 1248(x7=%ymm13 vmovupd 1248(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm13,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#15 # asm 2: vpand v01=%ymm14 vpand %ymm14,%ymm3,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm9,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm14,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm13,%ymm5,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#13 # asm 2: vpand v01=%ymm12 vpand %ymm12,%ymm5,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm7,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 1024 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 1280(x0=%ymm6 vmovupd 1280(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 1312 ] # asm 1: vmovupd 1312(x1=reg256#8 # asm 2: vmovupd 1312(x1=%ymm7 vmovupd 1312(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 1344 ] # asm 1: vmovupd 1344(x2=reg256#9 # asm 2: vmovupd 1344(x2=%ymm8 vmovupd 1344(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 1376 ] # asm 1: vmovupd 1376(x3=reg256#10 # asm 2: vmovupd 1376(x3=%ymm9 vmovupd 1376(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1408 ] # asm 1: vmovupd 1408(x4=reg256#11 # asm 2: vmovupd 1408(x4=%ymm10 vmovupd 1408(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1440 ] # asm 1: vmovupd 1440(x5=reg256#12 # asm 2: vmovupd 1440(x5=%ymm11 vmovupd 1440(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1472 ] # asm 1: vmovupd 1472(x6=reg256#13 # asm 2: vmovupd 1472(x6=%ymm12 vmovupd 1472(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1504 ] # asm 1: vmovupd 1504(x7=reg256#14 # asm 2: vmovupd 1504(x7=%ymm13 vmovupd 1504(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm13,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#15 # asm 2: vpand v01=%ymm14 vpand %ymm14,%ymm3,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm9,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm14,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm13,%ymm5,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#13 # asm 2: vpand v01=%ymm12 vpand %ymm12,%ymm5,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm7,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 1280 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 1536(x0=%ymm6 vmovupd 1536(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 1568 ] # asm 1: vmovupd 1568(x1=reg256#8 # asm 2: vmovupd 1568(x1=%ymm7 vmovupd 1568(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 1600 ] # asm 1: vmovupd 1600(x2=reg256#9 # asm 2: vmovupd 1600(x2=%ymm8 vmovupd 1600(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 1632 ] # asm 1: vmovupd 1632(x3=reg256#10 # asm 2: vmovupd 1632(x3=%ymm9 vmovupd 1632(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1664 ] # asm 1: vmovupd 1664(x4=reg256#11 # asm 2: vmovupd 1664(x4=%ymm10 vmovupd 1664(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1696 ] # asm 1: vmovupd 1696(x5=reg256#12 # asm 2: vmovupd 1696(x5=%ymm11 vmovupd 1696(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1728 ] # asm 1: vmovupd 1728(x6=reg256#13 # asm 2: vmovupd 1728(x6=%ymm12 vmovupd 1728(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 1760 ] # asm 1: vmovupd 1760(x7=reg256#14 # asm 2: vmovupd 1760(x7=%ymm13 vmovupd 1760(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm13,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#14 # asm 2: vpand v11=%ymm13 vpand %ymm13,%ymm1,%ymm13 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#13 # asm 2: vpor x3=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#10 # asm 2: vpor x7=%ymm9 vpor %ymm9,%ymm13,%ymm9 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#14 # asm 2: vpand v00=%ymm13 vpand %ymm14,%ymm2,%ymm13 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#15 # asm 2: vpand v01=%ymm14 vpand %ymm14,%ymm3,%ymm14 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#14 # asm 2: vpor x0=%ymm13 vpor %ymm13,%ymm15,%ymm13 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm14,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm10,%ymm2,%ymm14 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm3,%ymm12 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#15 # asm 2: vpor x1=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm10,%ymm12,%ymm10 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm2,%ymm12 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#13 # asm 2: vpor x4=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm9,%ymm2,%ymm15 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm9,%ymm3,%ymm9 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm8,%ymm15,%ymm8 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#8 # asm 2: vpor x7=%ymm7 vpor %ymm7,%ymm9,%ymm7 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm13,%ymm4,%ymm9 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm14,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm13,%ymm5,%ymm13 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#15 # asm 2: vpand v11=%ymm14 vpand %ymm14,%ymm5,%ymm14 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm15,%ymm9 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#14 # asm 2: vpor x1=%ymm13 vpor %ymm13,%ymm14,%ymm13 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm11,%ymm4,%ymm14 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#15 # asm 2: vpor x2=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#11 # asm 2: vpor x3=%ymm10 vpor %ymm11,%ymm10,%ymm10 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm12,%ymm4,%ymm11 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm8,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#13 # asm 2: vpand v01=%ymm12 vpand %ymm12,%ymm5,%ymm12 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm5,%ymm8 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#12 # asm 2: vpor x4=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#9 # asm 2: vpor x5=%ymm8 vpor %ymm12,%ymm8,%ymm8 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm6,%ymm4,%ymm12 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm7,%ymm4,%ymm15 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#8 # asm 2: vpand v11=%ymm7 vpand %ymm7,%ymm5,%ymm7 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#13 # asm 2: vpor x6=%ymm12 vpor %ymm12,%ymm15,%ymm12 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#7 # asm 2: vpor x7=%ymm6 vpor %ymm6,%ymm7,%ymm6 # qhasm: mem256[ input_0 + 1536 ] = x0 # asm 1: vmovupd x0=reg256#7 # asm 2: vmovupd 1792(x0=%ymm6 vmovupd 1792(%rdi),%ymm6 # qhasm: x1 = mem256[ input_0 + 1824 ] # asm 1: vmovupd 1824(x1=reg256#8 # asm 2: vmovupd 1824(x1=%ymm7 vmovupd 1824(%rdi),%ymm7 # qhasm: x2 = mem256[ input_0 + 1856 ] # asm 1: vmovupd 1856(x2=reg256#9 # asm 2: vmovupd 1856(x2=%ymm8 vmovupd 1856(%rdi),%ymm8 # qhasm: x3 = mem256[ input_0 + 1888 ] # asm 1: vmovupd 1888(x3=reg256#10 # asm 2: vmovupd 1888(x3=%ymm9 vmovupd 1888(%rdi),%ymm9 # qhasm: x4 = mem256[ input_0 + 1920 ] # asm 1: vmovupd 1920(x4=reg256#11 # asm 2: vmovupd 1920(x4=%ymm10 vmovupd 1920(%rdi),%ymm10 # qhasm: x5 = mem256[ input_0 + 1952 ] # asm 1: vmovupd 1952(x5=reg256#12 # asm 2: vmovupd 1952(x5=%ymm11 vmovupd 1952(%rdi),%ymm11 # qhasm: x6 = mem256[ input_0 + 1984 ] # asm 1: vmovupd 1984(x6=reg256#13 # asm 2: vmovupd 1984(x6=%ymm12 vmovupd 1984(%rdi),%ymm12 # qhasm: x7 = mem256[ input_0 + 2016 ] # asm 1: vmovupd 2016(x7=reg256#14 # asm 2: vmovupd 2016(x7=%ymm13 vmovupd 2016(%rdi),%ymm13 # qhasm: v00 = x0 & mask0 # asm 1: vpand v00=reg256#15 # asm 2: vpand v00=%ymm14 vpand %ymm6,%ymm0,%ymm14 # qhasm: v10 = x4 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm10,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm1,%ymm6 # qhasm: v11 = x4 & mask1 # asm 1: vpand v11=reg256#11 # asm 2: vpand v11=%ymm10 vpand %ymm10,%ymm1,%ymm10 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x0=reg256#15 # asm 2: vpor x0=%ymm14 vpor %ymm14,%ymm15,%ymm14 # qhasm: x4 = v01 | v11 # asm 1: vpor x4=reg256#7 # asm 2: vpor x4=%ymm6 vpor %ymm6,%ymm10,%ymm6 # qhasm: v00 = x1 & mask0 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm7,%ymm0,%ymm10 # qhasm: v10 = x5 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm11,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm1,%ymm7 # qhasm: v11 = x5 & mask1 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm1,%ymm11 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x1=reg256#11 # asm 2: vpor x1=%ymm10 vpor %ymm10,%ymm15,%ymm10 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#8 # asm 2: vpor x5=%ymm7 vpor %ymm7,%ymm11,%ymm7 # qhasm: v00 = x2 & mask0 # asm 1: vpand v00=reg256#12 # asm 2: vpand v00=%ymm11 vpand %ymm8,%ymm0,%ymm11 # qhasm: v10 = x6 & mask0 # asm 1: vpand v10=reg256#16 # asm 2: vpand v10=%ymm15 vpand %ymm12,%ymm0,%ymm15 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm8,%ymm1,%ymm8 # qhasm: v11 = x6 & mask1 # asm 1: vpand v11=reg256#13 # asm 2: vpand v11=%ymm12 vpand %ymm12,%ymm1,%ymm12 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm11,%ymm15,%ymm11 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#9 # asm 2: vpor x6=%ymm8 vpor %ymm8,%ymm12,%ymm8 # qhasm: v00 = x3 & mask0 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm9,%ymm0,%ymm12 # qhasm: v10 = x7 & mask0 # asm 1: vpand v10=reg256#1 # asm 2: vpand v10=%ymm0 vpand %ymm13,%ymm0,%ymm0 # qhasm: 4x v10 <<= 4 # asm 1: vpsllq $4,v01=reg256#10 # asm 2: vpand v01=%ymm9 vpand %ymm9,%ymm1,%ymm9 # qhasm: v11 = x7 & mask1 # asm 1: vpand v11=reg256#2 # asm 2: vpand v11=%ymm1 vpand %ymm13,%ymm1,%ymm1 # qhasm: 4x v01 unsigned>>= 4 # asm 1: vpsrlq $4,x3=reg256#1 # asm 2: vpor x3=%ymm0 vpor %ymm12,%ymm0,%ymm0 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#2 # asm 2: vpor x7=%ymm1 vpor %ymm9,%ymm1,%ymm1 # qhasm: v00 = x0 & mask2 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm14,%ymm2,%ymm9 # qhasm: v10 = x2 & mask2 # asm 1: vpand v10=reg256#13 # asm 2: vpand v10=%ymm12 vpand %ymm11,%ymm2,%ymm12 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#14 # asm 2: vpand v01=%ymm13 vpand %ymm14,%ymm3,%ymm13 # qhasm: v11 = x2 & mask3 # asm 1: vpand v11=reg256#12 # asm 2: vpand v11=%ymm11 vpand %ymm11,%ymm3,%ymm11 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x0=reg256#10 # asm 2: vpor x0=%ymm9 vpor %ymm9,%ymm12,%ymm9 # qhasm: x2 = v01 | v11 # asm 1: vpor x2=reg256#12 # asm 2: vpor x2=%ymm11 vpor %ymm13,%ymm11,%ymm11 # qhasm: v00 = x1 & mask2 # asm 1: vpand v00=reg256#13 # asm 2: vpand v00=%ymm12 vpand %ymm10,%ymm2,%ymm12 # qhasm: v10 = x3 & mask2 # asm 1: vpand v10=reg256#14 # asm 2: vpand v10=%ymm13 vpand %ymm0,%ymm2,%ymm13 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm3,%ymm10 # qhasm: v11 = x3 & mask3 # asm 1: vpand v11=reg256#1 # asm 2: vpand v11=%ymm0 vpand %ymm0,%ymm3,%ymm0 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x1=reg256#13 # asm 2: vpor x1=%ymm12 vpor %ymm12,%ymm13,%ymm12 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#1 # asm 2: vpor x3=%ymm0 vpor %ymm10,%ymm0,%ymm0 # qhasm: v00 = x4 & mask2 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm6,%ymm2,%ymm10 # qhasm: v10 = x6 & mask2 # asm 1: vpand v10=reg256#14 # asm 2: vpand v10=%ymm13 vpand %ymm8,%ymm2,%ymm13 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm3,%ymm6 # qhasm: v11 = x6 & mask3 # asm 1: vpand v11=reg256#9 # asm 2: vpand v11=%ymm8 vpand %ymm8,%ymm3,%ymm8 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x4=reg256#11 # asm 2: vpor x4=%ymm10 vpor %ymm10,%ymm13,%ymm10 # qhasm: x6 = v01 | v11 # asm 1: vpor x6=reg256#7 # asm 2: vpor x6=%ymm6 vpor %ymm6,%ymm8,%ymm6 # qhasm: v00 = x5 & mask2 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm7,%ymm2,%ymm8 # qhasm: v10 = x7 & mask2 # asm 1: vpand v10=reg256#3 # asm 2: vpand v10=%ymm2 vpand %ymm1,%ymm2,%ymm2 # qhasm: 4x v10 <<= 2 # asm 1: vpsllq $2,v01=reg256#8 # asm 2: vpand v01=%ymm7 vpand %ymm7,%ymm3,%ymm7 # qhasm: v11 = x7 & mask3 # asm 1: vpand v11=reg256#2 # asm 2: vpand v11=%ymm1 vpand %ymm1,%ymm3,%ymm1 # qhasm: 4x v01 unsigned>>= 2 # asm 1: vpsrlq $2,x5=reg256#3 # asm 2: vpor x5=%ymm2 vpor %ymm8,%ymm2,%ymm2 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#2 # asm 2: vpor x7=%ymm1 vpor %ymm7,%ymm1,%ymm1 # qhasm: v00 = x0 & mask4 # asm 1: vpand v00=reg256#4 # asm 2: vpand v00=%ymm3 vpand %ymm9,%ymm4,%ymm3 # qhasm: v10 = x1 & mask4 # asm 1: vpand v10=reg256#8 # asm 2: vpand v10=%ymm7 vpand %ymm12,%ymm4,%ymm7 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#9 # asm 2: vpand v01=%ymm8 vpand %ymm9,%ymm5,%ymm8 # qhasm: v11 = x1 & mask5 # asm 1: vpand v11=reg256#10 # asm 2: vpand v11=%ymm9 vpand %ymm12,%ymm5,%ymm9 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x0=reg256#4 # asm 2: vpor x0=%ymm3 vpor %ymm3,%ymm7,%ymm3 # qhasm: x1 = v01 | v11 # asm 1: vpor x1=reg256#8 # asm 2: vpor x1=%ymm7 vpor %ymm8,%ymm9,%ymm7 # qhasm: v00 = x2 & mask4 # asm 1: vpand v00=reg256#9 # asm 2: vpand v00=%ymm8 vpand %ymm11,%ymm4,%ymm8 # qhasm: v10 = x3 & mask4 # asm 1: vpand v10=reg256#10 # asm 2: vpand v10=%ymm9 vpand %ymm0,%ymm4,%ymm9 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#12 # asm 2: vpand v01=%ymm11 vpand %ymm11,%ymm5,%ymm11 # qhasm: v11 = x3 & mask5 # asm 1: vpand v11=reg256#1 # asm 2: vpand v11=%ymm0 vpand %ymm0,%ymm5,%ymm0 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x2=reg256#9 # asm 2: vpor x2=%ymm8 vpor %ymm8,%ymm9,%ymm8 # qhasm: x3 = v01 | v11 # asm 1: vpor x3=reg256#1 # asm 2: vpor x3=%ymm0 vpor %ymm11,%ymm0,%ymm0 # qhasm: v00 = x4 & mask4 # asm 1: vpand v00=reg256#10 # asm 2: vpand v00=%ymm9 vpand %ymm10,%ymm4,%ymm9 # qhasm: v10 = x5 & mask4 # asm 1: vpand v10=reg256#12 # asm 2: vpand v10=%ymm11 vpand %ymm2,%ymm4,%ymm11 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#11 # asm 2: vpand v01=%ymm10 vpand %ymm10,%ymm5,%ymm10 # qhasm: v11 = x5 & mask5 # asm 1: vpand v11=reg256#3 # asm 2: vpand v11=%ymm2 vpand %ymm2,%ymm5,%ymm2 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x4=reg256#10 # asm 2: vpor x4=%ymm9 vpor %ymm9,%ymm11,%ymm9 # qhasm: x5 = v01 | v11 # asm 1: vpor x5=reg256#3 # asm 2: vpor x5=%ymm2 vpor %ymm10,%ymm2,%ymm2 # qhasm: v00 = x6 & mask4 # asm 1: vpand v00=reg256#11 # asm 2: vpand v00=%ymm10 vpand %ymm6,%ymm4,%ymm10 # qhasm: v10 = x7 & mask4 # asm 1: vpand v10=reg256#5 # asm 2: vpand v10=%ymm4 vpand %ymm1,%ymm4,%ymm4 # qhasm: 4x v10 <<= 1 # asm 1: vpsllq $1,v01=reg256#7 # asm 2: vpand v01=%ymm6 vpand %ymm6,%ymm5,%ymm6 # qhasm: v11 = x7 & mask5 # asm 1: vpand v11=reg256#2 # asm 2: vpand v11=%ymm1 vpand %ymm1,%ymm5,%ymm1 # qhasm: 4x v01 unsigned>>= 1 # asm 1: vpsrlq $1,x6=reg256#5 # asm 2: vpor x6=%ymm4 vpor %ymm10,%ymm4,%ymm4 # qhasm: x7 = v01 | v11 # asm 1: vpor x7=reg256#2 # asm 2: vpor x7=%ymm1 vpor %ymm6,%ymm1,%ymm1 # qhasm: mem256[ input_0 + 1792 ] = x0 # asm 1: vmovupd > 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 0 ] = x0 mem256[ input_0 + 256 ] = x1 mem256[ input_0 + 512 ] = x2 mem256[ input_0 + 768 ] = x3 mem256[ input_0 + 1024 ] = x4 mem256[ input_0 + 1280 ] = x5 mem256[ input_0 + 1536 ] = x6 mem256[ input_0 + 1792 ] = x7 x0 = mem256[ input_0 + 32 ] x1 = mem256[ input_0 + 288 ] x2 = mem256[ input_0 + 544 ] x3 = mem256[ input_0 + 800 ] x4 = mem256[ input_0 + 1056 ] x5 = mem256[ input_0 + 1312 ] x6 = mem256[ input_0 + 1568 ] x7 = mem256[ input_0 + 1824 ] v00 = x0 & mask0 4x v10 = x4 << 32 4x v01 = x0 unsigned>> 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 32 ] = x0 mem256[ input_0 + 288 ] = x1 mem256[ input_0 + 544 ] = x2 mem256[ input_0 + 800 ] = x3 mem256[ input_0 + 1056 ] = x4 mem256[ input_0 + 1312 ] = x5 mem256[ input_0 + 1568 ] = x6 mem256[ input_0 + 1824 ] = x7 x0 = mem256[ input_0 + 64 ] x1 = mem256[ input_0 + 320 ] x2 = mem256[ input_0 + 576 ] x3 = mem256[ input_0 + 832 ] x4 = mem256[ input_0 + 1088 ] x5 = mem256[ input_0 + 1344 ] x6 = mem256[ input_0 + 1600 ] x7 = mem256[ input_0 + 1856 ] v00 = x0 & mask0 4x v10 = x4 << 32 4x v01 = x0 unsigned>> 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 64 ] = x0 mem256[ input_0 + 320 ] = x1 mem256[ input_0 + 576 ] = x2 mem256[ input_0 + 832 ] = x3 mem256[ input_0 + 1088 ] = x4 mem256[ input_0 + 1344 ] = x5 mem256[ input_0 + 1600 ] = x6 mem256[ input_0 + 1856 ] = x7 x0 = mem256[ input_0 + 96 ] x1 = mem256[ input_0 + 352 ] x2 = mem256[ input_0 + 608 ] x3 = mem256[ input_0 + 864 ] x4 = mem256[ input_0 + 1120 ] x5 = mem256[ input_0 + 1376 ] x6 = mem256[ input_0 + 1632 ] x7 = mem256[ input_0 + 1888 ] v00 = x0 & mask0 4x v10 = x4 << 32 4x v01 = x0 unsigned>> 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 96 ] = x0 mem256[ input_0 + 352 ] = x1 mem256[ input_0 + 608 ] = x2 mem256[ input_0 + 864 ] = x3 mem256[ input_0 + 1120 ] = x4 mem256[ input_0 + 1376 ] = x5 mem256[ input_0 + 1632 ] = x6 mem256[ input_0 + 1888 ] = x7 x0 = mem256[ input_0 + 128 ] x1 = mem256[ input_0 + 384 ] x2 = mem256[ input_0 + 640 ] x3 = mem256[ input_0 + 896 ] x4 = mem256[ input_0 + 1152 ] x5 = mem256[ input_0 + 1408 ] x6 = mem256[ input_0 + 1664 ] x7 = mem256[ input_0 + 1920 ] v00 = x0 & mask0 4x v10 = x4 << 32 4x v01 = x0 unsigned>> 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 128 ] = x0 mem256[ input_0 + 384 ] = x1 mem256[ input_0 + 640 ] = x2 mem256[ input_0 + 896 ] = x3 mem256[ input_0 + 1152 ] = x4 mem256[ input_0 + 1408 ] = x5 mem256[ input_0 + 1664 ] = x6 mem256[ input_0 + 1920 ] = x7 x0 = mem256[ input_0 + 160 ] x1 = mem256[ input_0 + 416 ] x2 = mem256[ input_0 + 672 ] x3 = mem256[ input_0 + 928 ] x4 = mem256[ input_0 + 1184 ] x5 = mem256[ input_0 + 1440 ] x6 = mem256[ input_0 + 1696 ] x7 = mem256[ input_0 + 1952 ] v00 = x0 & mask0 4x v10 = x4 << 32 4x v01 = x0 unsigned>> 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 160 ] = x0 mem256[ input_0 + 416 ] = x1 mem256[ input_0 + 672 ] = x2 mem256[ input_0 + 928 ] = x3 mem256[ input_0 + 1184 ] = x4 mem256[ input_0 + 1440 ] = x5 mem256[ input_0 + 1696 ] = x6 mem256[ input_0 + 1952 ] = x7 x0 = mem256[ input_0 + 192 ] x1 = mem256[ input_0 + 448 ] x2 = mem256[ input_0 + 704 ] x3 = mem256[ input_0 + 960 ] x4 = mem256[ input_0 + 1216 ] x5 = mem256[ input_0 + 1472 ] x6 = mem256[ input_0 + 1728 ] x7 = mem256[ input_0 + 1984 ] v00 = x0 & mask0 4x v10 = x4 << 32 4x v01 = x0 unsigned>> 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 192 ] = x0 mem256[ input_0 + 448 ] = x1 mem256[ input_0 + 704 ] = x2 mem256[ input_0 + 960 ] = x3 mem256[ input_0 + 1216 ] = x4 mem256[ input_0 + 1472 ] = x5 mem256[ input_0 + 1728 ] = x6 mem256[ input_0 + 1984 ] = x7 x0 = mem256[ input_0 + 224 ] x1 = mem256[ input_0 + 480 ] x2 = mem256[ input_0 + 736 ] x3 = mem256[ input_0 + 992 ] x4 = mem256[ input_0 + 1248 ] x5 = mem256[ input_0 + 1504 ] x6 = mem256[ input_0 + 1760 ] x7 = mem256[ input_0 + 2016 ] v00 = x0 & mask0 4x v10 = x4 << 32 4x v01 = x0 unsigned>> 32 v11 = x4 & mask1 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 4x v10 = x5 << 32 4x v01 = x1 unsigned>> 32 v11 = x5 & mask1 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 4x v10 = x6 << 32 4x v01 = x2 unsigned>> 32 v11 = x6 & mask1 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 4x v10 = x7 << 32 4x v01 = x3 unsigned>> 32 v11 = x7 & mask1 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 8x v10 = x2 << 16 8x v01 = x0 unsigned>> 16 v11 = x2 & mask3 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 8x v10 = x3 << 16 8x v01 = x1 unsigned>> 16 v11 = x3 & mask3 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 8x v10 = x6 << 16 8x v01 = x4 unsigned>> 16 v11 = x6 & mask3 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 8x v10 = x7 << 16 8x v01 = x5 unsigned>> 16 v11 = x7 & mask3 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 16x v10 = x1 << 8 16x v01 = x0 unsigned>> 8 v11 = x1 & mask5 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 16x v10 = x3 << 8 16x v01 = x2 unsigned>> 8 v11 = x3 & mask5 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 16x v10 = x5 << 8 16x v01 = x4 unsigned>> 8 v11 = x5 & mask5 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 16x v10 = x7 << 8 16x v01 = x6 unsigned>> 8 v11 = x7 & mask5 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 224 ] = x0 mem256[ input_0 + 480 ] = x1 mem256[ input_0 + 736 ] = x2 mem256[ input_0 + 992 ] = x3 mem256[ input_0 + 1248 ] = x4 mem256[ input_0 + 1504 ] = x5 mem256[ input_0 + 1760 ] = x6 mem256[ input_0 + 2016 ] = x7 mask0 aligned= mem256[ MASK2_0 ] mask1 aligned= mem256[ MASK2_1 ] mask2 aligned= mem256[ MASK1_0 ] mask3 aligned= mem256[ MASK1_1 ] mask4 aligned= mem256[ MASK0_0 ] mask5 aligned= mem256[ MASK0_1 ] x0 = mem256[ input_0 + 0 ] x1 = mem256[ input_0 + 32 ] x2 = mem256[ input_0 + 64 ] x3 = mem256[ input_0 + 96 ] x4 = mem256[ input_0 + 128 ] x5 = mem256[ input_0 + 160 ] x6 = mem256[ input_0 + 192 ] x7 = mem256[ input_0 + 224 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 0 ] = x0 mem256[ input_0 + 32 ] = x1 mem256[ input_0 + 64 ] = x2 mem256[ input_0 + 96 ] = x3 mem256[ input_0 + 128 ] = x4 mem256[ input_0 + 160 ] = x5 mem256[ input_0 + 192 ] = x6 mem256[ input_0 + 224 ] = x7 x0 = mem256[ input_0 + 256 ] x1 = mem256[ input_0 + 288 ] x2 = mem256[ input_0 + 320 ] x3 = mem256[ input_0 + 352 ] x4 = mem256[ input_0 + 384 ] x5 = mem256[ input_0 + 416 ] x6 = mem256[ input_0 + 448 ] x7 = mem256[ input_0 + 480 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 256 ] = x0 mem256[ input_0 + 288 ] = x1 mem256[ input_0 + 320 ] = x2 mem256[ input_0 + 352 ] = x3 mem256[ input_0 + 384 ] = x4 mem256[ input_0 + 416 ] = x5 mem256[ input_0 + 448 ] = x6 mem256[ input_0 + 480 ] = x7 x0 = mem256[ input_0 + 512 ] x1 = mem256[ input_0 + 544 ] x2 = mem256[ input_0 + 576 ] x3 = mem256[ input_0 + 608 ] x4 = mem256[ input_0 + 640 ] x5 = mem256[ input_0 + 672 ] x6 = mem256[ input_0 + 704 ] x7 = mem256[ input_0 + 736 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 512 ] = x0 mem256[ input_0 + 544 ] = x1 mem256[ input_0 + 576 ] = x2 mem256[ input_0 + 608 ] = x3 mem256[ input_0 + 640 ] = x4 mem256[ input_0 + 672 ] = x5 mem256[ input_0 + 704 ] = x6 mem256[ input_0 + 736 ] = x7 x0 = mem256[ input_0 + 768 ] x1 = mem256[ input_0 + 800 ] x2 = mem256[ input_0 + 832 ] x3 = mem256[ input_0 + 864 ] x4 = mem256[ input_0 + 896 ] x5 = mem256[ input_0 + 928 ] x6 = mem256[ input_0 + 960 ] x7 = mem256[ input_0 + 992 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 768 ] = x0 mem256[ input_0 + 800 ] = x1 mem256[ input_0 + 832 ] = x2 mem256[ input_0 + 864 ] = x3 mem256[ input_0 + 896 ] = x4 mem256[ input_0 + 928 ] = x5 mem256[ input_0 + 960 ] = x6 mem256[ input_0 + 992 ] = x7 x0 = mem256[ input_0 + 1024 ] x1 = mem256[ input_0 + 1056 ] x2 = mem256[ input_0 + 1088 ] x3 = mem256[ input_0 + 1120 ] x4 = mem256[ input_0 + 1152 ] x5 = mem256[ input_0 + 1184 ] x6 = mem256[ input_0 + 1216 ] x7 = mem256[ input_0 + 1248 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 1024 ] = x0 mem256[ input_0 + 1056 ] = x1 mem256[ input_0 + 1088 ] = x2 mem256[ input_0 + 1120 ] = x3 mem256[ input_0 + 1152 ] = x4 mem256[ input_0 + 1184 ] = x5 mem256[ input_0 + 1216 ] = x6 mem256[ input_0 + 1248 ] = x7 x0 = mem256[ input_0 + 1280 ] x1 = mem256[ input_0 + 1312 ] x2 = mem256[ input_0 + 1344 ] x3 = mem256[ input_0 + 1376 ] x4 = mem256[ input_0 + 1408 ] x5 = mem256[ input_0 + 1440 ] x6 = mem256[ input_0 + 1472 ] x7 = mem256[ input_0 + 1504 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 1280 ] = x0 mem256[ input_0 + 1312 ] = x1 mem256[ input_0 + 1344 ] = x2 mem256[ input_0 + 1376 ] = x3 mem256[ input_0 + 1408 ] = x4 mem256[ input_0 + 1440 ] = x5 mem256[ input_0 + 1472 ] = x6 mem256[ input_0 + 1504 ] = x7 x0 = mem256[ input_0 + 1536 ] x1 = mem256[ input_0 + 1568 ] x2 = mem256[ input_0 + 1600 ] x3 = mem256[ input_0 + 1632 ] x4 = mem256[ input_0 + 1664 ] x5 = mem256[ input_0 + 1696 ] x6 = mem256[ input_0 + 1728 ] x7 = mem256[ input_0 + 1760 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 1536 ] = x0 mem256[ input_0 + 1568 ] = x1 mem256[ input_0 + 1600 ] = x2 mem256[ input_0 + 1632 ] = x3 mem256[ input_0 + 1664 ] = x4 mem256[ input_0 + 1696 ] = x5 mem256[ input_0 + 1728 ] = x6 mem256[ input_0 + 1760 ] = x7 x0 = mem256[ input_0 + 1792 ] x1 = mem256[ input_0 + 1824 ] x2 = mem256[ input_0 + 1856 ] x3 = mem256[ input_0 + 1888 ] x4 = mem256[ input_0 + 1920 ] x5 = mem256[ input_0 + 1952 ] x6 = mem256[ input_0 + 1984 ] x7 = mem256[ input_0 + 2016 ] v00 = x0 & mask0 v10 = x4 & mask0 4x v10 <<= 4 v01 = x0 & mask1 v11 = x4 & mask1 4x v01 unsigned>>= 4 x0 = v00 | v10 x4 = v01 | v11 v00 = x1 & mask0 v10 = x5 & mask0 4x v10 <<= 4 v01 = x1 & mask1 v11 = x5 & mask1 4x v01 unsigned>>= 4 x1 = v00 | v10 x5 = v01 | v11 v00 = x2 & mask0 v10 = x6 & mask0 4x v10 <<= 4 v01 = x2 & mask1 v11 = x6 & mask1 4x v01 unsigned>>= 4 x2 = v00 | v10 x6 = v01 | v11 v00 = x3 & mask0 v10 = x7 & mask0 4x v10 <<= 4 v01 = x3 & mask1 v11 = x7 & mask1 4x v01 unsigned>>= 4 x3 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask2 v10 = x2 & mask2 4x v10 <<= 2 v01 = x0 & mask3 v11 = x2 & mask3 4x v01 unsigned>>= 2 x0 = v00 | v10 x2 = v01 | v11 v00 = x1 & mask2 v10 = x3 & mask2 4x v10 <<= 2 v01 = x1 & mask3 v11 = x3 & mask3 4x v01 unsigned>>= 2 x1 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask2 v10 = x6 & mask2 4x v10 <<= 2 v01 = x4 & mask3 v11 = x6 & mask3 4x v01 unsigned>>= 2 x4 = v00 | v10 x6 = v01 | v11 v00 = x5 & mask2 v10 = x7 & mask2 4x v10 <<= 2 v01 = x5 & mask3 v11 = x7 & mask3 4x v01 unsigned>>= 2 x5 = v00 | v10 x7 = v01 | v11 v00 = x0 & mask4 v10 = x1 & mask4 4x v10 <<= 1 v01 = x0 & mask5 v11 = x1 & mask5 4x v01 unsigned>>= 1 x0 = v00 | v10 x1 = v01 | v11 v00 = x2 & mask4 v10 = x3 & mask4 4x v10 <<= 1 v01 = x2 & mask5 v11 = x3 & mask5 4x v01 unsigned>>= 1 x2 = v00 | v10 x3 = v01 | v11 v00 = x4 & mask4 v10 = x5 & mask4 4x v10 <<= 1 v01 = x4 & mask5 v11 = x5 & mask5 4x v01 unsigned>>= 1 x4 = v00 | v10 x5 = v01 | v11 v00 = x6 & mask4 v10 = x7 & mask4 4x v10 <<= 1 v01 = x6 & mask5 v11 = x7 & mask5 4x v01 unsigned>>= 1 x6 = v00 | v10 x7 = v01 | v11 mem256[ input_0 + 1792 ] = x0 mem256[ input_0 + 1824 ] = x1 mem256[ input_0 + 1856 ] = x2 mem256[ input_0 + 1888 ] = x3 mem256[ input_0 + 1920 ] = x4 mem256[ input_0 + 1952 ] = x5 mem256[ input_0 + 1984 ] = x6 mem256[ input_0 + 2016 ] = x7 return libmceliece-20230612/crypto_kem/348864/avx/transpose_64x64_asm.S0000644000000000000000000076350714441554467022355 0ustar rootroot// 20221231 djb: port hidden to macos; tnx thom wiggers // 20221230 djb: add linker lines // linker define transpose_64x64_asm // linker use MASK0_0 MASK1_0 MASK2_0 MASK3_0 MASK4_0 MASK5_0 // linker use MASK0_1 MASK1_1 MASK2_1 MASK3_1 MASK4_1 MASK5_1 #include "crypto_asm_hidden.h" #define MASK0_0 CRYPTO_SHARED_NAMESPACE(MASK0_0) #define _MASK0_0 _CRYPTO_SHARED_NAMESPACE(MASK0_0) #define MASK0_1 CRYPTO_SHARED_NAMESPACE(MASK0_1) #define _MASK0_1 _CRYPTO_SHARED_NAMESPACE(MASK0_1) #define MASK1_0 CRYPTO_SHARED_NAMESPACE(MASK1_0) #define _MASK1_0 _CRYPTO_SHARED_NAMESPACE(MASK1_0) #define MASK1_1 CRYPTO_SHARED_NAMESPACE(MASK1_1) #define _MASK1_1 _CRYPTO_SHARED_NAMESPACE(MASK1_1) #define MASK2_0 CRYPTO_SHARED_NAMESPACE(MASK2_0) #define _MASK2_0 _CRYPTO_SHARED_NAMESPACE(MASK2_0) #define MASK2_1 CRYPTO_SHARED_NAMESPACE(MASK2_1) #define _MASK2_1 _CRYPTO_SHARED_NAMESPACE(MASK2_1) #define MASK3_0 CRYPTO_SHARED_NAMESPACE(MASK3_0) #define _MASK3_0 _CRYPTO_SHARED_NAMESPACE(MASK3_0) #define MASK3_1 CRYPTO_SHARED_NAMESPACE(MASK3_1) #define _MASK3_1 _CRYPTO_SHARED_NAMESPACE(MASK3_1) #define MASK4_0 CRYPTO_SHARED_NAMESPACE(MASK4_0) #define _MASK4_0 _CRYPTO_SHARED_NAMESPACE(MASK4_0) #define MASK4_1 CRYPTO_SHARED_NAMESPACE(MASK4_1) #define _MASK4_1 _CRYPTO_SHARED_NAMESPACE(MASK4_1) #define MASK5_0 CRYPTO_SHARED_NAMESPACE(MASK5_0) #define _MASK5_0 _CRYPTO_SHARED_NAMESPACE(MASK5_0) #define MASK5_1 CRYPTO_SHARED_NAMESPACE(MASK5_1) #define _MASK5_1 _CRYPTO_SHARED_NAMESPACE(MASK5_1) #define transpose_64x64_asm CRYPTO_SHARED_NAMESPACE(transpose_64x64_asm) #define _transpose_64x64_asm _CRYPTO_SHARED_NAMESPACE(transpose_64x64_asm) # qhasm: int64 input_0 # qhasm: int64 input_1 # qhasm: int64 input_2 # qhasm: int64 input_3 # qhasm: int64 input_4 # qhasm: int64 input_5 # qhasm: stack64 input_6 # qhasm: stack64 input_7 # qhasm: int64 caller_r11 # qhasm: int64 caller_r12 # qhasm: int64 caller_r13 # qhasm: int64 caller_r14 # qhasm: int64 caller_r15 # qhasm: int64 caller_rbx # qhasm: int64 caller_rbp # qhasm: reg128 r0 # qhasm: reg128 r1 # qhasm: reg128 r2 # qhasm: reg128 r3 # qhasm: reg128 r4 # qhasm: reg128 r5 # qhasm: reg128 r6 # qhasm: reg128 r7 # qhasm: reg128 t0 # qhasm: reg128 t1 # qhasm: reg128 v00 # qhasm: reg128 v01 # qhasm: reg128 v10 # qhasm: reg128 v11 # qhasm: int64 buf # qhasm: reg128 mask0 # qhasm: reg128 mask1 # qhasm: reg128 mask2 # qhasm: reg128 mask3 # qhasm: reg128 mask4 # qhasm: reg128 mask5 # qhasm: enter transpose_64x64_asm .p2align 5 ASM_HIDDEN _transpose_64x64_asm ASM_HIDDEN transpose_64x64_asm .global _transpose_64x64_asm .global transpose_64x64_asm _transpose_64x64_asm: transpose_64x64_asm: mov %rsp,%r11 and $31,%r11 add $0,%r11 sub %r11,%rsp # qhasm: mask0 aligned= mem128[ MASK5_0 ] # asm 1: movdqa MASK5_0(%rip),>mask0=reg128#1 # asm 2: movdqa MASK5_0(%rip),>mask0=%xmm0 movdqa MASK5_0(%rip),%xmm0 # qhasm: mask1 aligned= mem128[ MASK5_1 ] # asm 1: movdqa MASK5_1(%rip),>mask1=reg128#2 # asm 2: movdqa MASK5_1(%rip),>mask1=%xmm1 movdqa MASK5_1(%rip),%xmm1 # qhasm: mask2 aligned= mem128[ MASK4_0 ] # asm 1: movdqa MASK4_0(%rip),>mask2=reg128#3 # asm 2: movdqa MASK4_0(%rip),>mask2=%xmm2 movdqa MASK4_0(%rip),%xmm2 # qhasm: mask3 aligned= mem128[ MASK4_1 ] # asm 1: movdqa MASK4_1(%rip),>mask3=reg128#4 # asm 2: movdqa MASK4_1(%rip),>mask3=%xmm3 movdqa MASK4_1(%rip),%xmm3 # qhasm: mask4 aligned= mem128[ MASK3_0 ] # asm 1: movdqa MASK3_0(%rip),>mask4=reg128#5 # asm 2: movdqa MASK3_0(%rip),>mask4=%xmm4 movdqa MASK3_0(%rip),%xmm4 # qhasm: mask5 aligned= mem128[ MASK3_1 ] # asm 1: movdqa MASK3_1(%rip),>mask5=reg128#6 # asm 2: movdqa MASK3_1(%rip),>mask5=%xmm5 movdqa MASK3_1(%rip),%xmm5 # qhasm: r0 = mem64[ input_0 + 0 ] x2 # asm 1: movddup 0(r0=reg128#7 # asm 2: movddup 0(r0=%xmm6 movddup 0(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 64 ] x2 # asm 1: movddup 64(r1=reg128#8 # asm 2: movddup 64(r1=%xmm7 movddup 64(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 128 ] x2 # asm 1: movddup 128(r2=reg128#9 # asm 2: movddup 128(r2=%xmm8 movddup 128(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 192 ] x2 # asm 1: movddup 192(r3=reg128#10 # asm 2: movddup 192(r3=%xmm9 movddup 192(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 256 ] x2 # asm 1: movddup 256(r4=reg128#11 # asm 2: movddup 256(r4=%xmm10 movddup 256(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 320 ] x2 # asm 1: movddup 320(r5=reg128#12 # asm 2: movddup 320(r5=%xmm11 movddup 320(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 384 ] x2 # asm 1: movddup 384(r6=reg128#13 # asm 2: movddup 384(r6=%xmm12 movddup 384(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 448 ] x2 # asm 1: movddup 448(r7=reg128#14 # asm 2: movddup 448(r7=%xmm13 movddup 448(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm13,%xmm15 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm11,%xmm15 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#15 # asm 2: vpsrld $16,v01=%xmm14 vpsrld $16,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm12,%xmm15 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm8,%xmm15 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm9,%xmm15 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm14,%xmm15 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#14 # asm 2: vpsrlw $8,v01=%xmm13 vpsrlw $8,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm10,%xmm15 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm8,%xmm15 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#13 # asm 2: vpsrlw $8,v01=%xmm12 vpsrlw $8,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm7,%xmm15 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 0 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm13,%rsi # qhasm: mem64[ input_0 + 64 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm14,%rsi # qhasm: mem64[ input_0 + 128 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm10,%rsi # qhasm: mem64[ input_0 + 192 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm11,%rsi # qhasm: mem64[ input_0 + 256 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 320 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm12,%rsi # qhasm: mem64[ input_0 + 384 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm6,%rsi # qhasm: mem64[ input_0 + 448 ] = buf # asm 1: movq r0=reg128#7 # asm 2: movddup 8(r0=%xmm6 movddup 8(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 72 ] x2 # asm 1: movddup 72(r1=reg128#8 # asm 2: movddup 72(r1=%xmm7 movddup 72(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 136 ] x2 # asm 1: movddup 136(r2=reg128#9 # asm 2: movddup 136(r2=%xmm8 movddup 136(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 200 ] x2 # asm 1: movddup 200(r3=reg128#10 # asm 2: movddup 200(r3=%xmm9 movddup 200(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 264 ] x2 # asm 1: movddup 264(r4=reg128#11 # asm 2: movddup 264(r4=%xmm10 movddup 264(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 328 ] x2 # asm 1: movddup 328(r5=reg128#12 # asm 2: movddup 328(r5=%xmm11 movddup 328(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 392 ] x2 # asm 1: movddup 392(r6=reg128#13 # asm 2: movddup 392(r6=%xmm12 movddup 392(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 456 ] x2 # asm 1: movddup 456(r7=reg128#14 # asm 2: movddup 456(r7=%xmm13 movddup 456(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm13,%xmm15 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm11,%xmm15 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#15 # asm 2: vpsrld $16,v01=%xmm14 vpsrld $16,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm12,%xmm15 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm8,%xmm15 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm9,%xmm15 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm14,%xmm15 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#14 # asm 2: vpsrlw $8,v01=%xmm13 vpsrlw $8,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm10,%xmm15 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm8,%xmm15 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#13 # asm 2: vpsrlw $8,v01=%xmm12 vpsrlw $8,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm7,%xmm15 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 8 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm13,%rsi # qhasm: mem64[ input_0 + 72 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm14,%rsi # qhasm: mem64[ input_0 + 136 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm10,%rsi # qhasm: mem64[ input_0 + 200 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm11,%rsi # qhasm: mem64[ input_0 + 264 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 328 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm12,%rsi # qhasm: mem64[ input_0 + 392 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm6,%rsi # qhasm: mem64[ input_0 + 456 ] = buf # asm 1: movq r0=reg128#7 # asm 2: movddup 16(r0=%xmm6 movddup 16(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 80 ] x2 # asm 1: movddup 80(r1=reg128#8 # asm 2: movddup 80(r1=%xmm7 movddup 80(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 144 ] x2 # asm 1: movddup 144(r2=reg128#9 # asm 2: movddup 144(r2=%xmm8 movddup 144(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 208 ] x2 # asm 1: movddup 208(r3=reg128#10 # asm 2: movddup 208(r3=%xmm9 movddup 208(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 272 ] x2 # asm 1: movddup 272(r4=reg128#11 # asm 2: movddup 272(r4=%xmm10 movddup 272(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 336 ] x2 # asm 1: movddup 336(r5=reg128#12 # asm 2: movddup 336(r5=%xmm11 movddup 336(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 400 ] x2 # asm 1: movddup 400(r6=reg128#13 # asm 2: movddup 400(r6=%xmm12 movddup 400(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 464 ] x2 # asm 1: movddup 464(r7=reg128#14 # asm 2: movddup 464(r7=%xmm13 movddup 464(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm13,%xmm15 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm11,%xmm15 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#15 # asm 2: vpsrld $16,v01=%xmm14 vpsrld $16,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm12,%xmm15 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm8,%xmm15 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm9,%xmm15 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm14,%xmm15 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#14 # asm 2: vpsrlw $8,v01=%xmm13 vpsrlw $8,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm10,%xmm15 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm8,%xmm15 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#13 # asm 2: vpsrlw $8,v01=%xmm12 vpsrlw $8,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm7,%xmm15 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 16 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm13,%rsi # qhasm: mem64[ input_0 + 80 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm14,%rsi # qhasm: mem64[ input_0 + 144 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm10,%rsi # qhasm: mem64[ input_0 + 208 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm11,%rsi # qhasm: mem64[ input_0 + 272 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 336 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm12,%rsi # qhasm: mem64[ input_0 + 400 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm6,%rsi # qhasm: mem64[ input_0 + 464 ] = buf # asm 1: movq r0=reg128#7 # asm 2: movddup 24(r0=%xmm6 movddup 24(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 88 ] x2 # asm 1: movddup 88(r1=reg128#8 # asm 2: movddup 88(r1=%xmm7 movddup 88(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 152 ] x2 # asm 1: movddup 152(r2=reg128#9 # asm 2: movddup 152(r2=%xmm8 movddup 152(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 216 ] x2 # asm 1: movddup 216(r3=reg128#10 # asm 2: movddup 216(r3=%xmm9 movddup 216(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 280 ] x2 # asm 1: movddup 280(r4=reg128#11 # asm 2: movddup 280(r4=%xmm10 movddup 280(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 344 ] x2 # asm 1: movddup 344(r5=reg128#12 # asm 2: movddup 344(r5=%xmm11 movddup 344(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 408 ] x2 # asm 1: movddup 408(r6=reg128#13 # asm 2: movddup 408(r6=%xmm12 movddup 408(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 472 ] x2 # asm 1: movddup 472(r7=reg128#14 # asm 2: movddup 472(r7=%xmm13 movddup 472(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm13,%xmm15 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm11,%xmm15 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#15 # asm 2: vpsrld $16,v01=%xmm14 vpsrld $16,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm12,%xmm15 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm8,%xmm15 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm9,%xmm15 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm14,%xmm15 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#14 # asm 2: vpsrlw $8,v01=%xmm13 vpsrlw $8,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm10,%xmm15 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm8,%xmm15 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#13 # asm 2: vpsrlw $8,v01=%xmm12 vpsrlw $8,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm7,%xmm15 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 24 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm13,%rsi # qhasm: mem64[ input_0 + 88 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm14,%rsi # qhasm: mem64[ input_0 + 152 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm10,%rsi # qhasm: mem64[ input_0 + 216 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm11,%rsi # qhasm: mem64[ input_0 + 280 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 344 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm12,%rsi # qhasm: mem64[ input_0 + 408 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm6,%rsi # qhasm: mem64[ input_0 + 472 ] = buf # asm 1: movq r0=reg128#7 # asm 2: movddup 32(r0=%xmm6 movddup 32(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 96 ] x2 # asm 1: movddup 96(r1=reg128#8 # asm 2: movddup 96(r1=%xmm7 movddup 96(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 160 ] x2 # asm 1: movddup 160(r2=reg128#9 # asm 2: movddup 160(r2=%xmm8 movddup 160(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 224 ] x2 # asm 1: movddup 224(r3=reg128#10 # asm 2: movddup 224(r3=%xmm9 movddup 224(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 288 ] x2 # asm 1: movddup 288(r4=reg128#11 # asm 2: movddup 288(r4=%xmm10 movddup 288(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 352 ] x2 # asm 1: movddup 352(r5=reg128#12 # asm 2: movddup 352(r5=%xmm11 movddup 352(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 416 ] x2 # asm 1: movddup 416(r6=reg128#13 # asm 2: movddup 416(r6=%xmm12 movddup 416(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 480 ] x2 # asm 1: movddup 480(r7=reg128#14 # asm 2: movddup 480(r7=%xmm13 movddup 480(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm13,%xmm15 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm11,%xmm15 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#15 # asm 2: vpsrld $16,v01=%xmm14 vpsrld $16,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm12,%xmm15 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm8,%xmm15 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm9,%xmm15 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm14,%xmm15 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#14 # asm 2: vpsrlw $8,v01=%xmm13 vpsrlw $8,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm10,%xmm15 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm8,%xmm15 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#13 # asm 2: vpsrlw $8,v01=%xmm12 vpsrlw $8,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm7,%xmm15 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 32 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm13,%rsi # qhasm: mem64[ input_0 + 96 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm14,%rsi # qhasm: mem64[ input_0 + 160 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm10,%rsi # qhasm: mem64[ input_0 + 224 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm11,%rsi # qhasm: mem64[ input_0 + 288 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 352 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm12,%rsi # qhasm: mem64[ input_0 + 416 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm6,%rsi # qhasm: mem64[ input_0 + 480 ] = buf # asm 1: movq r0=reg128#7 # asm 2: movddup 40(r0=%xmm6 movddup 40(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 104 ] x2 # asm 1: movddup 104(r1=reg128#8 # asm 2: movddup 104(r1=%xmm7 movddup 104(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 168 ] x2 # asm 1: movddup 168(r2=reg128#9 # asm 2: movddup 168(r2=%xmm8 movddup 168(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 232 ] x2 # asm 1: movddup 232(r3=reg128#10 # asm 2: movddup 232(r3=%xmm9 movddup 232(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 296 ] x2 # asm 1: movddup 296(r4=reg128#11 # asm 2: movddup 296(r4=%xmm10 movddup 296(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 360 ] x2 # asm 1: movddup 360(r5=reg128#12 # asm 2: movddup 360(r5=%xmm11 movddup 360(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 424 ] x2 # asm 1: movddup 424(r6=reg128#13 # asm 2: movddup 424(r6=%xmm12 movddup 424(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 488 ] x2 # asm 1: movddup 488(r7=reg128#14 # asm 2: movddup 488(r7=%xmm13 movddup 488(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm13,%xmm15 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm11,%xmm15 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#15 # asm 2: vpsrld $16,v01=%xmm14 vpsrld $16,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm12,%xmm15 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm8,%xmm15 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm9,%xmm15 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm14,%xmm15 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#14 # asm 2: vpsrlw $8,v01=%xmm13 vpsrlw $8,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm10,%xmm15 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm8,%xmm15 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#13 # asm 2: vpsrlw $8,v01=%xmm12 vpsrlw $8,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm7,%xmm15 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 40 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm13,%rsi # qhasm: mem64[ input_0 + 104 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm14,%rsi # qhasm: mem64[ input_0 + 168 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm10,%rsi # qhasm: mem64[ input_0 + 232 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm11,%rsi # qhasm: mem64[ input_0 + 296 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 360 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm12,%rsi # qhasm: mem64[ input_0 + 424 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm6,%rsi # qhasm: mem64[ input_0 + 488 ] = buf # asm 1: movq r0=reg128#7 # asm 2: movddup 48(r0=%xmm6 movddup 48(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 112 ] x2 # asm 1: movddup 112(r1=reg128#8 # asm 2: movddup 112(r1=%xmm7 movddup 112(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 176 ] x2 # asm 1: movddup 176(r2=reg128#9 # asm 2: movddup 176(r2=%xmm8 movddup 176(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 240 ] x2 # asm 1: movddup 240(r3=reg128#10 # asm 2: movddup 240(r3=%xmm9 movddup 240(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 304 ] x2 # asm 1: movddup 304(r4=reg128#11 # asm 2: movddup 304(r4=%xmm10 movddup 304(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 368 ] x2 # asm 1: movddup 368(r5=reg128#12 # asm 2: movddup 368(r5=%xmm11 movddup 368(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 432 ] x2 # asm 1: movddup 432(r6=reg128#13 # asm 2: movddup 432(r6=%xmm12 movddup 432(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 496 ] x2 # asm 1: movddup 496(r7=reg128#14 # asm 2: movddup 496(r7=%xmm13 movddup 496(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm13,%xmm15 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm11,%xmm15 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#15 # asm 2: vpsrld $16,v01=%xmm14 vpsrld $16,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm12,%xmm15 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm8,%xmm15 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#16 # asm 2: vpslld $16,v10=%xmm15 vpslld $16,%xmm9,%xmm15 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm14,%xmm15 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#14 # asm 2: vpsrlw $8,v01=%xmm13 vpsrlw $8,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm10,%xmm15 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm8,%xmm15 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#13 # asm 2: vpsrlw $8,v01=%xmm12 vpsrlw $8,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#16 # asm 2: vpsllw $8,v10=%xmm15 vpsllw $8,%xmm7,%xmm15 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 48 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm13,%rsi # qhasm: mem64[ input_0 + 112 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm14,%rsi # qhasm: mem64[ input_0 + 176 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm10,%rsi # qhasm: mem64[ input_0 + 240 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm11,%rsi # qhasm: mem64[ input_0 + 304 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 368 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm12,%rsi # qhasm: mem64[ input_0 + 432 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm6,%rsi # qhasm: mem64[ input_0 + 496 ] = buf # asm 1: movq r0=reg128#7 # asm 2: movddup 56(r0=%xmm6 movddup 56(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 120 ] x2 # asm 1: movddup 120(r1=reg128#8 # asm 2: movddup 120(r1=%xmm7 movddup 120(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 184 ] x2 # asm 1: movddup 184(r2=reg128#9 # asm 2: movddup 184(r2=%xmm8 movddup 184(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 248 ] x2 # asm 1: movddup 248(r3=reg128#10 # asm 2: movddup 248(r3=%xmm9 movddup 248(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 312 ] x2 # asm 1: movddup 312(r4=reg128#11 # asm 2: movddup 312(r4=%xmm10 movddup 312(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 376 ] x2 # asm 1: movddup 376(r5=reg128#12 # asm 2: movddup 376(r5=%xmm11 movddup 376(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 440 ] x2 # asm 1: movddup 440(r6=reg128#13 # asm 2: movddup 440(r6=%xmm12 movddup 440(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 504 ] x2 # asm 1: movddup 504(r7=reg128#14 # asm 2: movddup 504(r7=%xmm13 movddup 504(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: 2x v10 = r4 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm10,%xmm15 # qhasm: 2x v01 = r0 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#7 # asm 2: vpsrlq $32,v01=%xmm6 vpsrlq $32,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: 2x v10 = r5 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm11,%xmm15 # qhasm: 2x v01 = r1 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#8 # asm 2: vpsrlq $32,v01=%xmm7 vpsrlq $32,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: 2x v10 = r6 << 32 # asm 1: vpsllq $32,v10=reg128#16 # asm 2: vpsllq $32,v10=%xmm15 vpsllq $32,%xmm12,%xmm15 # qhasm: 2x v01 = r2 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#9 # asm 2: vpsrlq $32,v01=%xmm8 vpsrlq $32,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#1 # asm 2: vpand v00=%xmm0 vpand %xmm0,%xmm9,%xmm0 # qhasm: 2x v10 = r7 << 32 # asm 1: vpsllq $32,v10=reg128#13 # asm 2: vpsllq $32,v10=%xmm12 vpsllq $32,%xmm13,%xmm12 # qhasm: 2x v01 = r3 unsigned>> 32 # asm 1: vpsrlq $32,v01=reg128#10 # asm 2: vpsrlq $32,v01=%xmm9 vpsrlq $32,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#2 # asm 2: vpand v11=%xmm1 vpand %xmm1,%xmm13,%xmm1 # qhasm: r3 = v00 | v10 # asm 1: vpor r3=reg128#1 # asm 2: vpor r3=%xmm0 vpor %xmm12,%xmm0,%xmm0 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#2 # asm 2: vpor r7=%xmm1 vpor %xmm1,%xmm9,%xmm1 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm2,%xmm14,%xmm9 # qhasm: 4x v10 = r2 << 16 # asm 1: vpslld $16,v10=reg128#13 # asm 2: vpslld $16,v10=%xmm12 vpslld $16,%xmm11,%xmm12 # qhasm: 4x v01 = r0 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#14 # asm 2: vpsrld $16,v01=%xmm13 vpsrld $16,%xmm14,%xmm13 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm12,%xmm9,%xmm9 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm13,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm10,%xmm12 # qhasm: 4x v10 = r3 << 16 # asm 1: vpslld $16,v10=reg128#14 # asm 2: vpslld $16,v10=%xmm13 vpslld $16,%xmm0,%xmm13 # qhasm: 4x v01 = r1 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#11 # asm 2: vpsrld $16,v01=%xmm10 vpsrld $16,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#1 # asm 2: vpand v11=%xmm0 vpand %xmm3,%xmm0,%xmm0 # qhasm: r1 = v00 | v10 # asm 1: vpor r1=reg128#13 # asm 2: vpor r1=%xmm12 vpor %xmm13,%xmm12,%xmm12 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#1 # asm 2: vpor r3=%xmm0 vpor %xmm0,%xmm10,%xmm0 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm2,%xmm6,%xmm10 # qhasm: 4x v10 = r6 << 16 # asm 1: vpslld $16,v10=reg128#14 # asm 2: vpslld $16,v10=%xmm13 vpslld $16,%xmm8,%xmm13 # qhasm: 4x v01 = r4 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#7 # asm 2: vpsrld $16,v01=%xmm6 vpsrld $16,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#11 # asm 2: vpor r4=%xmm10 vpor %xmm13,%xmm10,%xmm10 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#3 # asm 2: vpand v00=%xmm2 vpand %xmm2,%xmm7,%xmm2 # qhasm: 4x v10 = r7 << 16 # asm 1: vpslld $16,v10=reg128#9 # asm 2: vpslld $16,v10=%xmm8 vpslld $16,%xmm1,%xmm8 # qhasm: 4x v01 = r5 unsigned>> 16 # asm 1: vpsrld $16,v01=reg128#8 # asm 2: vpsrld $16,v01=%xmm7 vpsrld $16,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#2 # asm 2: vpand v11=%xmm1 vpand %xmm3,%xmm1,%xmm1 # qhasm: r5 = v00 | v10 # asm 1: vpor r5=reg128#3 # asm 2: vpor r5=%xmm2 vpor %xmm8,%xmm2,%xmm2 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#2 # asm 2: vpor r7=%xmm1 vpor %xmm1,%xmm7,%xmm1 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#4 # asm 2: vpand v00=%xmm3 vpand %xmm4,%xmm9,%xmm3 # qhasm: 8x v10 = r1 << 8 # asm 1: vpsllw $8,v10=reg128#8 # asm 2: vpsllw $8,v10=%xmm7 vpsllw $8,%xmm12,%xmm7 # qhasm: 8x v01 = r0 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#9 # asm 2: vpsrlw $8,v01=%xmm8 vpsrlw $8,%xmm9,%xmm8 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm5,%xmm12,%xmm9 # qhasm: r0 = v00 | v10 # asm 1: vpor r0=reg128#4 # asm 2: vpor r0=%xmm3 vpor %xmm7,%xmm3,%xmm3 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#8 # asm 2: vpor r1=%xmm7 vpor %xmm9,%xmm8,%xmm7 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm4,%xmm11,%xmm8 # qhasm: 8x v10 = r3 << 8 # asm 1: vpsllw $8,v10=reg128#10 # asm 2: vpsllw $8,v10=%xmm9 vpsllw $8,%xmm0,%xmm9 # qhasm: 8x v01 = r2 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#12 # asm 2: vpsrlw $8,v01=%xmm11 vpsrlw $8,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#1 # asm 2: vpand v11=%xmm0 vpand %xmm5,%xmm0,%xmm0 # qhasm: r2 = v00 | v10 # asm 1: vpor r2=reg128#9 # asm 2: vpor r2=%xmm8 vpor %xmm9,%xmm8,%xmm8 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#1 # asm 2: vpor r3=%xmm0 vpor %xmm0,%xmm11,%xmm0 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm10,%xmm9 # qhasm: 8x v10 = r5 << 8 # asm 1: vpsllw $8,v10=reg128#12 # asm 2: vpsllw $8,v10=%xmm11 vpsllw $8,%xmm2,%xmm11 # qhasm: 8x v01 = r4 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#11 # asm 2: vpsrlw $8,v01=%xmm10 vpsrlw $8,%xmm10,%xmm10 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#3 # asm 2: vpand v11=%xmm2 vpand %xmm5,%xmm2,%xmm2 # qhasm: r4 = v00 | v10 # asm 1: vpor r4=reg128#10 # asm 2: vpor r4=%xmm9 vpor %xmm11,%xmm9,%xmm9 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#3 # asm 2: vpor r5=%xmm2 vpor %xmm2,%xmm10,%xmm2 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#5 # asm 2: vpand v00=%xmm4 vpand %xmm4,%xmm6,%xmm4 # qhasm: 8x v10 = r7 << 8 # asm 1: vpsllw $8,v10=reg128#11 # asm 2: vpsllw $8,v10=%xmm10 vpsllw $8,%xmm1,%xmm10 # qhasm: 8x v01 = r6 unsigned>> 8 # asm 1: vpsrlw $8,v01=reg128#7 # asm 2: vpsrlw $8,v01=%xmm6 vpsrlw $8,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#2 # asm 2: vpand v11=%xmm1 vpand %xmm5,%xmm1,%xmm1 # qhasm: r6 = v00 | v10 # asm 1: vpor r6=reg128#5 # asm 2: vpor r6=%xmm4 vpor %xmm10,%xmm4,%xmm4 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#2 # asm 2: vpor r7=%xmm1 vpor %xmm1,%xmm6,%xmm1 # qhasm: buf = r0[0] # asm 1: pextrq $0x0,buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm3,%rsi # qhasm: mem64[ input_0 + 56 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm7,%rsi # qhasm: mem64[ input_0 + 120 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm8,%rsi # qhasm: mem64[ input_0 + 184 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm0,%rsi # qhasm: mem64[ input_0 + 248 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm9,%rsi # qhasm: mem64[ input_0 + 312 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm2,%rsi # qhasm: mem64[ input_0 + 376 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm4,%rsi # qhasm: mem64[ input_0 + 440 ] = buf # asm 1: movq buf=int64#2 # asm 2: pextrq $0x0,buf=%rsi pextrq $0x0,%xmm1,%rsi # qhasm: mem64[ input_0 + 504 ] = buf # asm 1: movq mask0=reg128#1 # asm 2: movdqa MASK2_0(%rip),>mask0=%xmm0 movdqa MASK2_0(%rip),%xmm0 # qhasm: mask1 aligned= mem128[ MASK2_1 ] # asm 1: movdqa MASK2_1(%rip),>mask1=reg128#2 # asm 2: movdqa MASK2_1(%rip),>mask1=%xmm1 movdqa MASK2_1(%rip),%xmm1 # qhasm: mask2 aligned= mem128[ MASK1_0 ] # asm 1: movdqa MASK1_0(%rip),>mask2=reg128#3 # asm 2: movdqa MASK1_0(%rip),>mask2=%xmm2 movdqa MASK1_0(%rip),%xmm2 # qhasm: mask3 aligned= mem128[ MASK1_1 ] # asm 1: movdqa MASK1_1(%rip),>mask3=reg128#4 # asm 2: movdqa MASK1_1(%rip),>mask3=%xmm3 movdqa MASK1_1(%rip),%xmm3 # qhasm: mask4 aligned= mem128[ MASK0_0 ] # asm 1: movdqa MASK0_0(%rip),>mask4=reg128#5 # asm 2: movdqa MASK0_0(%rip),>mask4=%xmm4 movdqa MASK0_0(%rip),%xmm4 # qhasm: mask5 aligned= mem128[ MASK0_1 ] # asm 1: movdqa MASK0_1(%rip),>mask5=reg128#6 # asm 2: movdqa MASK0_1(%rip),>mask5=%xmm5 movdqa MASK0_1(%rip),%xmm5 # qhasm: r0 = mem64[ input_0 + 0 ] x2 # asm 1: movddup 0(r0=reg128#7 # asm 2: movddup 0(r0=%xmm6 movddup 0(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 8 ] x2 # asm 1: movddup 8(r1=reg128#8 # asm 2: movddup 8(r1=%xmm7 movddup 8(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 16 ] x2 # asm 1: movddup 16(r2=reg128#9 # asm 2: movddup 16(r2=%xmm8 movddup 16(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 24 ] x2 # asm 1: movddup 24(r3=reg128#10 # asm 2: movddup 24(r3=%xmm9 movddup 24(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 32 ] x2 # asm 1: movddup 32(r4=reg128#11 # asm 2: movddup 32(r4=%xmm10 movddup 32(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 40 ] x2 # asm 1: movddup 40(r5=reg128#12 # asm 2: movddup 40(r5=%xmm11 movddup 40(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 48 ] x2 # asm 1: movddup 48(r6=reg128#13 # asm 2: movddup 48(r6=%xmm12 movddup 48(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 56 ] x2 # asm 1: movddup 56(r7=reg128#14 # asm 2: movddup 56(r7=%xmm13 movddup 56(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm13,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm11,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#15 # asm 2: vpand v01=%xmm14 vpand %xmm3,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm12,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm8,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm9,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm14,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm5,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm10,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm8,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#13 # asm 2: vpand v01=%xmm12 vpand %xmm5,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm7,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm13,%xmm9,%xmm7 # qhasm: mem128[ input_0 + 0 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm10,%xmm14,%xmm7 # qhasm: mem128[ input_0 + 16 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm8,%xmm11,%xmm7 # qhasm: mem128[ input_0 + 32 ] = t0 # asm 1: movdqu t0=reg128#7 # asm 2: vpunpcklqdq t0=%xmm6 vpunpcklqdq %xmm6,%xmm12,%xmm6 # qhasm: mem128[ input_0 + 48 ] = t0 # asm 1: movdqu r0=reg128#7 # asm 2: movddup 64(r0=%xmm6 movddup 64(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 72 ] x2 # asm 1: movddup 72(r1=reg128#8 # asm 2: movddup 72(r1=%xmm7 movddup 72(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 80 ] x2 # asm 1: movddup 80(r2=reg128#9 # asm 2: movddup 80(r2=%xmm8 movddup 80(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 88 ] x2 # asm 1: movddup 88(r3=reg128#10 # asm 2: movddup 88(r3=%xmm9 movddup 88(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 96 ] x2 # asm 1: movddup 96(r4=reg128#11 # asm 2: movddup 96(r4=%xmm10 movddup 96(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 104 ] x2 # asm 1: movddup 104(r5=reg128#12 # asm 2: movddup 104(r5=%xmm11 movddup 104(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 112 ] x2 # asm 1: movddup 112(r6=reg128#13 # asm 2: movddup 112(r6=%xmm12 movddup 112(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 120 ] x2 # asm 1: movddup 120(r7=reg128#14 # asm 2: movddup 120(r7=%xmm13 movddup 120(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm13,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm11,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#15 # asm 2: vpand v01=%xmm14 vpand %xmm3,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm12,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm8,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm9,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm14,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm5,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm10,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm8,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#13 # asm 2: vpand v01=%xmm12 vpand %xmm5,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm7,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm13,%xmm9,%xmm7 # qhasm: mem128[ input_0 + 64 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm10,%xmm14,%xmm7 # qhasm: mem128[ input_0 + 80 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm8,%xmm11,%xmm7 # qhasm: mem128[ input_0 + 96 ] = t0 # asm 1: movdqu t0=reg128#7 # asm 2: vpunpcklqdq t0=%xmm6 vpunpcklqdq %xmm6,%xmm12,%xmm6 # qhasm: mem128[ input_0 + 112 ] = t0 # asm 1: movdqu r0=reg128#7 # asm 2: movddup 128(r0=%xmm6 movddup 128(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 136 ] x2 # asm 1: movddup 136(r1=reg128#8 # asm 2: movddup 136(r1=%xmm7 movddup 136(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 144 ] x2 # asm 1: movddup 144(r2=reg128#9 # asm 2: movddup 144(r2=%xmm8 movddup 144(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 152 ] x2 # asm 1: movddup 152(r3=reg128#10 # asm 2: movddup 152(r3=%xmm9 movddup 152(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 160 ] x2 # asm 1: movddup 160(r4=reg128#11 # asm 2: movddup 160(r4=%xmm10 movddup 160(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 168 ] x2 # asm 1: movddup 168(r5=reg128#12 # asm 2: movddup 168(r5=%xmm11 movddup 168(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 176 ] x2 # asm 1: movddup 176(r6=reg128#13 # asm 2: movddup 176(r6=%xmm12 movddup 176(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 184 ] x2 # asm 1: movddup 184(r7=reg128#14 # asm 2: movddup 184(r7=%xmm13 movddup 184(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm13,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm11,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#15 # asm 2: vpand v01=%xmm14 vpand %xmm3,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm12,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm8,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm9,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm14,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm5,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm10,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm8,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#13 # asm 2: vpand v01=%xmm12 vpand %xmm5,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm7,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm13,%xmm9,%xmm7 # qhasm: mem128[ input_0 + 128 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm10,%xmm14,%xmm7 # qhasm: mem128[ input_0 + 144 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm8,%xmm11,%xmm7 # qhasm: mem128[ input_0 + 160 ] = t0 # asm 1: movdqu t0=reg128#7 # asm 2: vpunpcklqdq t0=%xmm6 vpunpcklqdq %xmm6,%xmm12,%xmm6 # qhasm: mem128[ input_0 + 176 ] = t0 # asm 1: movdqu r0=reg128#7 # asm 2: movddup 192(r0=%xmm6 movddup 192(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 200 ] x2 # asm 1: movddup 200(r1=reg128#8 # asm 2: movddup 200(r1=%xmm7 movddup 200(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 208 ] x2 # asm 1: movddup 208(r2=reg128#9 # asm 2: movddup 208(r2=%xmm8 movddup 208(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 216 ] x2 # asm 1: movddup 216(r3=reg128#10 # asm 2: movddup 216(r3=%xmm9 movddup 216(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 224 ] x2 # asm 1: movddup 224(r4=reg128#11 # asm 2: movddup 224(r4=%xmm10 movddup 224(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 232 ] x2 # asm 1: movddup 232(r5=reg128#12 # asm 2: movddup 232(r5=%xmm11 movddup 232(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 240 ] x2 # asm 1: movddup 240(r6=reg128#13 # asm 2: movddup 240(r6=%xmm12 movddup 240(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 248 ] x2 # asm 1: movddup 248(r7=reg128#14 # asm 2: movddup 248(r7=%xmm13 movddup 248(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm13,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm11,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#15 # asm 2: vpand v01=%xmm14 vpand %xmm3,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm12,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm8,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm9,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm14,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm5,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm10,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm8,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#13 # asm 2: vpand v01=%xmm12 vpand %xmm5,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm7,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm13,%xmm9,%xmm7 # qhasm: mem128[ input_0 + 192 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm10,%xmm14,%xmm7 # qhasm: mem128[ input_0 + 208 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm8,%xmm11,%xmm7 # qhasm: mem128[ input_0 + 224 ] = t0 # asm 1: movdqu t0=reg128#7 # asm 2: vpunpcklqdq t0=%xmm6 vpunpcklqdq %xmm6,%xmm12,%xmm6 # qhasm: mem128[ input_0 + 240 ] = t0 # asm 1: movdqu r0=reg128#7 # asm 2: movddup 256(r0=%xmm6 movddup 256(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 264 ] x2 # asm 1: movddup 264(r1=reg128#8 # asm 2: movddup 264(r1=%xmm7 movddup 264(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 272 ] x2 # asm 1: movddup 272(r2=reg128#9 # asm 2: movddup 272(r2=%xmm8 movddup 272(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 280 ] x2 # asm 1: movddup 280(r3=reg128#10 # asm 2: movddup 280(r3=%xmm9 movddup 280(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 288 ] x2 # asm 1: movddup 288(r4=reg128#11 # asm 2: movddup 288(r4=%xmm10 movddup 288(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 296 ] x2 # asm 1: movddup 296(r5=reg128#12 # asm 2: movddup 296(r5=%xmm11 movddup 296(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 304 ] x2 # asm 1: movddup 304(r6=reg128#13 # asm 2: movddup 304(r6=%xmm12 movddup 304(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 312 ] x2 # asm 1: movddup 312(r7=reg128#14 # asm 2: movddup 312(r7=%xmm13 movddup 312(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm13,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm11,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#15 # asm 2: vpand v01=%xmm14 vpand %xmm3,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm12,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm8,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm9,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm14,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm5,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm10,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm8,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#13 # asm 2: vpand v01=%xmm12 vpand %xmm5,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm7,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm13,%xmm9,%xmm7 # qhasm: mem128[ input_0 + 256 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm10,%xmm14,%xmm7 # qhasm: mem128[ input_0 + 272 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm8,%xmm11,%xmm7 # qhasm: mem128[ input_0 + 288 ] = t0 # asm 1: movdqu t0=reg128#7 # asm 2: vpunpcklqdq t0=%xmm6 vpunpcklqdq %xmm6,%xmm12,%xmm6 # qhasm: mem128[ input_0 + 304 ] = t0 # asm 1: movdqu r0=reg128#7 # asm 2: movddup 320(r0=%xmm6 movddup 320(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 328 ] x2 # asm 1: movddup 328(r1=reg128#8 # asm 2: movddup 328(r1=%xmm7 movddup 328(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 336 ] x2 # asm 1: movddup 336(r2=reg128#9 # asm 2: movddup 336(r2=%xmm8 movddup 336(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 344 ] x2 # asm 1: movddup 344(r3=reg128#10 # asm 2: movddup 344(r3=%xmm9 movddup 344(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 352 ] x2 # asm 1: movddup 352(r4=reg128#11 # asm 2: movddup 352(r4=%xmm10 movddup 352(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 360 ] x2 # asm 1: movddup 360(r5=reg128#12 # asm 2: movddup 360(r5=%xmm11 movddup 360(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 368 ] x2 # asm 1: movddup 368(r6=reg128#13 # asm 2: movddup 368(r6=%xmm12 movddup 368(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 376 ] x2 # asm 1: movddup 376(r7=reg128#14 # asm 2: movddup 376(r7=%xmm13 movddup 376(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm13,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm11,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#15 # asm 2: vpand v01=%xmm14 vpand %xmm3,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm12,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm8,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm9,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm14,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm5,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm10,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm8,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#13 # asm 2: vpand v01=%xmm12 vpand %xmm5,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm7,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm13,%xmm9,%xmm7 # qhasm: mem128[ input_0 + 320 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm10,%xmm14,%xmm7 # qhasm: mem128[ input_0 + 336 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm8,%xmm11,%xmm7 # qhasm: mem128[ input_0 + 352 ] = t0 # asm 1: movdqu t0=reg128#7 # asm 2: vpunpcklqdq t0=%xmm6 vpunpcklqdq %xmm6,%xmm12,%xmm6 # qhasm: mem128[ input_0 + 368 ] = t0 # asm 1: movdqu r0=reg128#7 # asm 2: movddup 384(r0=%xmm6 movddup 384(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 392 ] x2 # asm 1: movddup 392(r1=reg128#8 # asm 2: movddup 392(r1=%xmm7 movddup 392(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 400 ] x2 # asm 1: movddup 400(r2=reg128#9 # asm 2: movddup 400(r2=%xmm8 movddup 400(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 408 ] x2 # asm 1: movddup 408(r3=reg128#10 # asm 2: movddup 408(r3=%xmm9 movddup 408(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 416 ] x2 # asm 1: movddup 416(r4=reg128#11 # asm 2: movddup 416(r4=%xmm10 movddup 416(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 424 ] x2 # asm 1: movddup 424(r5=reg128#12 # asm 2: movddup 424(r5=%xmm11 movddup 424(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 432 ] x2 # asm 1: movddup 432(r6=reg128#13 # asm 2: movddup 432(r6=%xmm12 movddup 432(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 440 ] x2 # asm 1: movddup 440(r7=reg128#14 # asm 2: movddup 440(r7=%xmm13 movddup 440(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm13,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#14 # asm 2: vpand v11=%xmm13 vpand %xmm1,%xmm13,%xmm13 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#13 # asm 2: vpor r3=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#10 # asm 2: vpor r7=%xmm9 vpor %xmm13,%xmm9,%xmm9 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#14 # asm 2: vpand v00=%xmm13 vpand %xmm2,%xmm14,%xmm13 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm11,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#15 # asm 2: vpand v01=%xmm14 vpand %xmm3,%xmm14,%xmm14 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#14 # asm 2: vpor r0=%xmm13 vpor %xmm15,%xmm13,%xmm13 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm14,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm2,%xmm10,%xmm14 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm12,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm3,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#15 # asm 2: vpor r1=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm12,%xmm10,%xmm10 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm6,%xmm12 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm8,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#13 # asm 2: vpor r4=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm2,%xmm9,%xmm15 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm3,%xmm9,%xmm9 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm15,%xmm8,%xmm8 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#8 # asm 2: vpor r7=%xmm7 vpor %xmm9,%xmm7,%xmm7 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm13,%xmm9 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm14,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm5,%xmm13,%xmm13 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#15 # asm 2: vpand v11=%xmm14 vpand %xmm5,%xmm14,%xmm14 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm15,%xmm9,%xmm9 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#14 # asm 2: vpor r1=%xmm13 vpor %xmm14,%xmm13,%xmm13 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm4,%xmm11,%xmm14 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm10,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#15 # asm 2: vpor r2=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#11 # asm 2: vpor r3=%xmm10 vpor %xmm10,%xmm11,%xmm10 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm4,%xmm12,%xmm11 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm8,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#13 # asm 2: vpand v01=%xmm12 vpand %xmm5,%xmm12,%xmm12 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm5,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#12 # asm 2: vpor r4=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#9 # asm 2: vpor r5=%xmm8 vpor %xmm8,%xmm12,%xmm8 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm4,%xmm6,%xmm12 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm4,%xmm7,%xmm15 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#8 # asm 2: vpand v11=%xmm7 vpand %xmm5,%xmm7,%xmm7 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#13 # asm 2: vpor r6=%xmm12 vpor %xmm15,%xmm12,%xmm12 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#7 # asm 2: vpor r7=%xmm6 vpor %xmm7,%xmm6,%xmm6 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm13,%xmm9,%xmm7 # qhasm: mem128[ input_0 + 384 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm10,%xmm14,%xmm7 # qhasm: mem128[ input_0 + 400 ] = t0 # asm 1: movdqu t0=reg128#8 # asm 2: vpunpcklqdq t0=%xmm7 vpunpcklqdq %xmm8,%xmm11,%xmm7 # qhasm: mem128[ input_0 + 416 ] = t0 # asm 1: movdqu t0=reg128#7 # asm 2: vpunpcklqdq t0=%xmm6 vpunpcklqdq %xmm6,%xmm12,%xmm6 # qhasm: mem128[ input_0 + 432 ] = t0 # asm 1: movdqu r0=reg128#7 # asm 2: movddup 448(r0=%xmm6 movddup 448(%rdi),%xmm6 # qhasm: r1 = mem64[ input_0 + 456 ] x2 # asm 1: movddup 456(r1=reg128#8 # asm 2: movddup 456(r1=%xmm7 movddup 456(%rdi),%xmm7 # qhasm: r2 = mem64[ input_0 + 464 ] x2 # asm 1: movddup 464(r2=reg128#9 # asm 2: movddup 464(r2=%xmm8 movddup 464(%rdi),%xmm8 # qhasm: r3 = mem64[ input_0 + 472 ] x2 # asm 1: movddup 472(r3=reg128#10 # asm 2: movddup 472(r3=%xmm9 movddup 472(%rdi),%xmm9 # qhasm: r4 = mem64[ input_0 + 480 ] x2 # asm 1: movddup 480(r4=reg128#11 # asm 2: movddup 480(r4=%xmm10 movddup 480(%rdi),%xmm10 # qhasm: r5 = mem64[ input_0 + 488 ] x2 # asm 1: movddup 488(r5=reg128#12 # asm 2: movddup 488(r5=%xmm11 movddup 488(%rdi),%xmm11 # qhasm: r6 = mem64[ input_0 + 496 ] x2 # asm 1: movddup 496(r6=reg128#13 # asm 2: movddup 496(r6=%xmm12 movddup 496(%rdi),%xmm12 # qhasm: r7 = mem64[ input_0 + 504 ] x2 # asm 1: movddup 504(r7=reg128#14 # asm 2: movddup 504(r7=%xmm13 movddup 504(%rdi),%xmm13 # qhasm: v00 = r0 & mask0 # asm 1: vpand v00=reg128#15 # asm 2: vpand v00=%xmm14 vpand %xmm0,%xmm6,%xmm14 # qhasm: v10 = r4 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm10,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm1,%xmm6,%xmm6 # qhasm: v11 = r4 & mask1 # asm 1: vpand v11=reg128#11 # asm 2: vpand v11=%xmm10 vpand %xmm1,%xmm10,%xmm10 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r0=reg128#15 # asm 2: vpor r0=%xmm14 vpor %xmm15,%xmm14,%xmm14 # qhasm: r4 = v01 | v11 # asm 1: vpor r4=reg128#7 # asm 2: vpor r4=%xmm6 vpor %xmm10,%xmm6,%xmm6 # qhasm: v00 = r1 & mask0 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm0,%xmm7,%xmm10 # qhasm: v10 = r5 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm11,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm1,%xmm7,%xmm7 # qhasm: v11 = r5 & mask1 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm1,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r1=reg128#11 # asm 2: vpor r1=%xmm10 vpor %xmm15,%xmm10,%xmm10 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#8 # asm 2: vpor r5=%xmm7 vpor %xmm11,%xmm7,%xmm7 # qhasm: v00 = r2 & mask0 # asm 1: vpand v00=reg128#12 # asm 2: vpand v00=%xmm11 vpand %xmm0,%xmm8,%xmm11 # qhasm: v10 = r6 & mask0 # asm 1: vpand v10=reg128#16 # asm 2: vpand v10=%xmm15 vpand %xmm0,%xmm12,%xmm15 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm1,%xmm8,%xmm8 # qhasm: v11 = r6 & mask1 # asm 1: vpand v11=reg128#13 # asm 2: vpand v11=%xmm12 vpand %xmm1,%xmm12,%xmm12 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm15,%xmm11,%xmm11 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#9 # asm 2: vpor r6=%xmm8 vpor %xmm12,%xmm8,%xmm8 # qhasm: v00 = r3 & mask0 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm0,%xmm9,%xmm12 # qhasm: v10 = r7 & mask0 # asm 1: vpand v10=reg128#1 # asm 2: vpand v10=%xmm0 vpand %xmm0,%xmm13,%xmm0 # qhasm: 2x v10 <<= 4 # asm 1: psllq $4,v01=reg128#10 # asm 2: vpand v01=%xmm9 vpand %xmm1,%xmm9,%xmm9 # qhasm: v11 = r7 & mask1 # asm 1: vpand v11=reg128#2 # asm 2: vpand v11=%xmm1 vpand %xmm1,%xmm13,%xmm1 # qhasm: 2x v01 unsigned>>= 4 # asm 1: psrlq $4,r3=reg128#1 # asm 2: vpor r3=%xmm0 vpor %xmm0,%xmm12,%xmm0 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#2 # asm 2: vpor r7=%xmm1 vpor %xmm1,%xmm9,%xmm1 # qhasm: v00 = r0 & mask2 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm2,%xmm14,%xmm9 # qhasm: v10 = r2 & mask2 # asm 1: vpand v10=reg128#13 # asm 2: vpand v10=%xmm12 vpand %xmm2,%xmm11,%xmm12 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#14 # asm 2: vpand v01=%xmm13 vpand %xmm3,%xmm14,%xmm13 # qhasm: v11 = r2 & mask3 # asm 1: vpand v11=reg128#12 # asm 2: vpand v11=%xmm11 vpand %xmm3,%xmm11,%xmm11 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r0=reg128#10 # asm 2: vpor r0=%xmm9 vpor %xmm12,%xmm9,%xmm9 # qhasm: r2 = v01 | v11 # asm 1: vpor r2=reg128#12 # asm 2: vpor r2=%xmm11 vpor %xmm11,%xmm13,%xmm11 # qhasm: v00 = r1 & mask2 # asm 1: vpand v00=reg128#13 # asm 2: vpand v00=%xmm12 vpand %xmm2,%xmm10,%xmm12 # qhasm: v10 = r3 & mask2 # asm 1: vpand v10=reg128#14 # asm 2: vpand v10=%xmm13 vpand %xmm2,%xmm0,%xmm13 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm3,%xmm10,%xmm10 # qhasm: v11 = r3 & mask3 # asm 1: vpand v11=reg128#1 # asm 2: vpand v11=%xmm0 vpand %xmm3,%xmm0,%xmm0 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r1=reg128#13 # asm 2: vpor r1=%xmm12 vpor %xmm13,%xmm12,%xmm12 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#1 # asm 2: vpor r3=%xmm0 vpor %xmm0,%xmm10,%xmm0 # qhasm: v00 = r4 & mask2 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm2,%xmm6,%xmm10 # qhasm: v10 = r6 & mask2 # asm 1: vpand v10=reg128#14 # asm 2: vpand v10=%xmm13 vpand %xmm2,%xmm8,%xmm13 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm3,%xmm6,%xmm6 # qhasm: v11 = r6 & mask3 # asm 1: vpand v11=reg128#9 # asm 2: vpand v11=%xmm8 vpand %xmm3,%xmm8,%xmm8 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r4=reg128#11 # asm 2: vpor r4=%xmm10 vpor %xmm13,%xmm10,%xmm10 # qhasm: r6 = v01 | v11 # asm 1: vpor r6=reg128#7 # asm 2: vpor r6=%xmm6 vpor %xmm8,%xmm6,%xmm6 # qhasm: v00 = r5 & mask2 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm2,%xmm7,%xmm8 # qhasm: v10 = r7 & mask2 # asm 1: vpand v10=reg128#3 # asm 2: vpand v10=%xmm2 vpand %xmm2,%xmm1,%xmm2 # qhasm: 2x v10 <<= 2 # asm 1: psllq $2,v01=reg128#8 # asm 2: vpand v01=%xmm7 vpand %xmm3,%xmm7,%xmm7 # qhasm: v11 = r7 & mask3 # asm 1: vpand v11=reg128#2 # asm 2: vpand v11=%xmm1 vpand %xmm3,%xmm1,%xmm1 # qhasm: 2x v01 unsigned>>= 2 # asm 1: psrlq $2,r5=reg128#3 # asm 2: vpor r5=%xmm2 vpor %xmm2,%xmm8,%xmm2 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#2 # asm 2: vpor r7=%xmm1 vpor %xmm1,%xmm7,%xmm1 # qhasm: v00 = r0 & mask4 # asm 1: vpand v00=reg128#4 # asm 2: vpand v00=%xmm3 vpand %xmm4,%xmm9,%xmm3 # qhasm: v10 = r1 & mask4 # asm 1: vpand v10=reg128#8 # asm 2: vpand v10=%xmm7 vpand %xmm4,%xmm12,%xmm7 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#9 # asm 2: vpand v01=%xmm8 vpand %xmm5,%xmm9,%xmm8 # qhasm: v11 = r1 & mask5 # asm 1: vpand v11=reg128#10 # asm 2: vpand v11=%xmm9 vpand %xmm5,%xmm12,%xmm9 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r0=reg128#4 # asm 2: vpor r0=%xmm3 vpor %xmm7,%xmm3,%xmm3 # qhasm: r1 = v01 | v11 # asm 1: vpor r1=reg128#8 # asm 2: vpor r1=%xmm7 vpor %xmm9,%xmm8,%xmm7 # qhasm: v00 = r2 & mask4 # asm 1: vpand v00=reg128#9 # asm 2: vpand v00=%xmm8 vpand %xmm4,%xmm11,%xmm8 # qhasm: v10 = r3 & mask4 # asm 1: vpand v10=reg128#10 # asm 2: vpand v10=%xmm9 vpand %xmm4,%xmm0,%xmm9 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#12 # asm 2: vpand v01=%xmm11 vpand %xmm5,%xmm11,%xmm11 # qhasm: v11 = r3 & mask5 # asm 1: vpand v11=reg128#1 # asm 2: vpand v11=%xmm0 vpand %xmm5,%xmm0,%xmm0 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r2=reg128#9 # asm 2: vpor r2=%xmm8 vpor %xmm9,%xmm8,%xmm8 # qhasm: r3 = v01 | v11 # asm 1: vpor r3=reg128#1 # asm 2: vpor r3=%xmm0 vpor %xmm0,%xmm11,%xmm0 # qhasm: v00 = r4 & mask4 # asm 1: vpand v00=reg128#10 # asm 2: vpand v00=%xmm9 vpand %xmm4,%xmm10,%xmm9 # qhasm: v10 = r5 & mask4 # asm 1: vpand v10=reg128#12 # asm 2: vpand v10=%xmm11 vpand %xmm4,%xmm2,%xmm11 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#11 # asm 2: vpand v01=%xmm10 vpand %xmm5,%xmm10,%xmm10 # qhasm: v11 = r5 & mask5 # asm 1: vpand v11=reg128#3 # asm 2: vpand v11=%xmm2 vpand %xmm5,%xmm2,%xmm2 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r4=reg128#10 # asm 2: vpor r4=%xmm9 vpor %xmm11,%xmm9,%xmm9 # qhasm: r5 = v01 | v11 # asm 1: vpor r5=reg128#3 # asm 2: vpor r5=%xmm2 vpor %xmm2,%xmm10,%xmm2 # qhasm: v00 = r6 & mask4 # asm 1: vpand v00=reg128#11 # asm 2: vpand v00=%xmm10 vpand %xmm4,%xmm6,%xmm10 # qhasm: v10 = r7 & mask4 # asm 1: vpand v10=reg128#5 # asm 2: vpand v10=%xmm4 vpand %xmm4,%xmm1,%xmm4 # qhasm: 2x v10 <<= 1 # asm 1: psllq $1,v01=reg128#7 # asm 2: vpand v01=%xmm6 vpand %xmm5,%xmm6,%xmm6 # qhasm: v11 = r7 & mask5 # asm 1: vpand v11=reg128#2 # asm 2: vpand v11=%xmm1 vpand %xmm5,%xmm1,%xmm1 # qhasm: 2x v01 unsigned>>= 1 # asm 1: psrlq $1,r6=reg128#5 # asm 2: vpor r6=%xmm4 vpor %xmm4,%xmm10,%xmm4 # qhasm: r7 = v01 | v11 # asm 1: vpor r7=reg128#2 # asm 2: vpor r7=%xmm1 vpor %xmm1,%xmm6,%xmm1 # qhasm: t0 = r0[0]r1[0] # asm 1: vpunpcklqdq t0=reg128#4 # asm 2: vpunpcklqdq t0=%xmm3 vpunpcklqdq %xmm7,%xmm3,%xmm3 # qhasm: mem128[ input_0 + 448 ] = t0 # asm 1: movdqu t0=reg128#1 # asm 2: vpunpcklqdq t0=%xmm0 vpunpcklqdq %xmm0,%xmm8,%xmm0 # qhasm: mem128[ input_0 + 464 ] = t0 # asm 1: movdqu t0=reg128#1 # asm 2: vpunpcklqdq t0=%xmm0 vpunpcklqdq %xmm2,%xmm9,%xmm0 # qhasm: mem128[ input_0 + 480 ] = t0 # asm 1: movdqu t0=reg128#1 # asm 2: vpunpcklqdq t0=%xmm0 vpunpcklqdq %xmm1,%xmm4,%xmm0 # qhasm: mem128[ input_0 + 496 ] = t0 # asm 1: movdqu > 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 0 ] = buf buf = r1[0] mem64[ input_0 + 64 ] = buf buf = r2[0] mem64[ input_0 + 128 ] = buf buf = r3[0] mem64[ input_0 + 192 ] = buf buf = r4[0] mem64[ input_0 + 256 ] = buf buf = r5[0] mem64[ input_0 + 320 ] = buf buf = r6[0] mem64[ input_0 + 384 ] = buf buf = r7[0] mem64[ input_0 + 448 ] = buf r0 = mem64[ input_0 + 8 ] x2 r1 = mem64[ input_0 + 72 ] x2 r2 = mem64[ input_0 + 136 ] x2 r3 = mem64[ input_0 + 200 ] x2 r4 = mem64[ input_0 + 264 ] x2 r5 = mem64[ input_0 + 328 ] x2 r6 = mem64[ input_0 + 392 ] x2 r7 = mem64[ input_0 + 456 ] x2 v00 = r0 & mask0 2x v10 = r4 << 32 2x v01 = r0 unsigned>> 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 8 ] = buf buf = r1[0] mem64[ input_0 + 72 ] = buf buf = r2[0] mem64[ input_0 + 136 ] = buf buf = r3[0] mem64[ input_0 + 200 ] = buf buf = r4[0] mem64[ input_0 + 264 ] = buf buf = r5[0] mem64[ input_0 + 328 ] = buf buf = r6[0] mem64[ input_0 + 392 ] = buf buf = r7[0] mem64[ input_0 + 456 ] = buf r0 = mem64[ input_0 + 16 ] x2 r1 = mem64[ input_0 + 80 ] x2 r2 = mem64[ input_0 + 144 ] x2 r3 = mem64[ input_0 + 208 ] x2 r4 = mem64[ input_0 + 272 ] x2 r5 = mem64[ input_0 + 336 ] x2 r6 = mem64[ input_0 + 400 ] x2 r7 = mem64[ input_0 + 464 ] x2 v00 = r0 & mask0 2x v10 = r4 << 32 2x v01 = r0 unsigned>> 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 16 ] = buf buf = r1[0] mem64[ input_0 + 80 ] = buf buf = r2[0] mem64[ input_0 + 144 ] = buf buf = r3[0] mem64[ input_0 + 208 ] = buf buf = r4[0] mem64[ input_0 + 272 ] = buf buf = r5[0] mem64[ input_0 + 336 ] = buf buf = r6[0] mem64[ input_0 + 400 ] = buf buf = r7[0] mem64[ input_0 + 464 ] = buf r0 = mem64[ input_0 + 24 ] x2 r1 = mem64[ input_0 + 88 ] x2 r2 = mem64[ input_0 + 152 ] x2 r3 = mem64[ input_0 + 216 ] x2 r4 = mem64[ input_0 + 280 ] x2 r5 = mem64[ input_0 + 344 ] x2 r6 = mem64[ input_0 + 408 ] x2 r7 = mem64[ input_0 + 472 ] x2 v00 = r0 & mask0 2x v10 = r4 << 32 2x v01 = r0 unsigned>> 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 24 ] = buf buf = r1[0] mem64[ input_0 + 88 ] = buf buf = r2[0] mem64[ input_0 + 152 ] = buf buf = r3[0] mem64[ input_0 + 216 ] = buf buf = r4[0] mem64[ input_0 + 280 ] = buf buf = r5[0] mem64[ input_0 + 344 ] = buf buf = r6[0] mem64[ input_0 + 408 ] = buf buf = r7[0] mem64[ input_0 + 472 ] = buf r0 = mem64[ input_0 + 32 ] x2 r1 = mem64[ input_0 + 96 ] x2 r2 = mem64[ input_0 + 160 ] x2 r3 = mem64[ input_0 + 224 ] x2 r4 = mem64[ input_0 + 288 ] x2 r5 = mem64[ input_0 + 352 ] x2 r6 = mem64[ input_0 + 416 ] x2 r7 = mem64[ input_0 + 480 ] x2 v00 = r0 & mask0 2x v10 = r4 << 32 2x v01 = r0 unsigned>> 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 32 ] = buf buf = r1[0] mem64[ input_0 + 96 ] = buf buf = r2[0] mem64[ input_0 + 160 ] = buf buf = r3[0] mem64[ input_0 + 224 ] = buf buf = r4[0] mem64[ input_0 + 288 ] = buf buf = r5[0] mem64[ input_0 + 352 ] = buf buf = r6[0] mem64[ input_0 + 416 ] = buf buf = r7[0] mem64[ input_0 + 480 ] = buf r0 = mem64[ input_0 + 40 ] x2 r1 = mem64[ input_0 + 104 ] x2 r2 = mem64[ input_0 + 168 ] x2 r3 = mem64[ input_0 + 232 ] x2 r4 = mem64[ input_0 + 296 ] x2 r5 = mem64[ input_0 + 360 ] x2 r6 = mem64[ input_0 + 424 ] x2 r7 = mem64[ input_0 + 488 ] x2 v00 = r0 & mask0 2x v10 = r4 << 32 2x v01 = r0 unsigned>> 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 40 ] = buf buf = r1[0] mem64[ input_0 + 104 ] = buf buf = r2[0] mem64[ input_0 + 168 ] = buf buf = r3[0] mem64[ input_0 + 232 ] = buf buf = r4[0] mem64[ input_0 + 296 ] = buf buf = r5[0] mem64[ input_0 + 360 ] = buf buf = r6[0] mem64[ input_0 + 424 ] = buf buf = r7[0] mem64[ input_0 + 488 ] = buf r0 = mem64[ input_0 + 48 ] x2 r1 = mem64[ input_0 + 112 ] x2 r2 = mem64[ input_0 + 176 ] x2 r3 = mem64[ input_0 + 240 ] x2 r4 = mem64[ input_0 + 304 ] x2 r5 = mem64[ input_0 + 368 ] x2 r6 = mem64[ input_0 + 432 ] x2 r7 = mem64[ input_0 + 496 ] x2 v00 = r0 & mask0 2x v10 = r4 << 32 2x v01 = r0 unsigned>> 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 48 ] = buf buf = r1[0] mem64[ input_0 + 112 ] = buf buf = r2[0] mem64[ input_0 + 176 ] = buf buf = r3[0] mem64[ input_0 + 240 ] = buf buf = r4[0] mem64[ input_0 + 304 ] = buf buf = r5[0] mem64[ input_0 + 368 ] = buf buf = r6[0] mem64[ input_0 + 432 ] = buf buf = r7[0] mem64[ input_0 + 496 ] = buf r0 = mem64[ input_0 + 56 ] x2 r1 = mem64[ input_0 + 120 ] x2 r2 = mem64[ input_0 + 184 ] x2 r3 = mem64[ input_0 + 248 ] x2 r4 = mem64[ input_0 + 312 ] x2 r5 = mem64[ input_0 + 376 ] x2 r6 = mem64[ input_0 + 440 ] x2 r7 = mem64[ input_0 + 504 ] x2 v00 = r0 & mask0 2x v10 = r4 << 32 2x v01 = r0 unsigned>> 32 v11 = r4 & mask1 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 2x v10 = r5 << 32 2x v01 = r1 unsigned>> 32 v11 = r5 & mask1 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 2x v10 = r6 << 32 2x v01 = r2 unsigned>> 32 v11 = r6 & mask1 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 2x v10 = r7 << 32 2x v01 = r3 unsigned>> 32 v11 = r7 & mask1 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 4x v10 = r2 << 16 4x v01 = r0 unsigned>> 16 v11 = r2 & mask3 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 4x v10 = r3 << 16 4x v01 = r1 unsigned>> 16 v11 = r3 & mask3 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 4x v10 = r6 << 16 4x v01 = r4 unsigned>> 16 v11 = r6 & mask3 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 4x v10 = r7 << 16 4x v01 = r5 unsigned>> 16 v11 = r7 & mask3 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 8x v10 = r1 << 8 8x v01 = r0 unsigned>> 8 v11 = r1 & mask5 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 8x v10 = r3 << 8 8x v01 = r2 unsigned>> 8 v11 = r3 & mask5 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 8x v10 = r5 << 8 8x v01 = r4 unsigned>> 8 v11 = r5 & mask5 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 8x v10 = r7 << 8 8x v01 = r6 unsigned>> 8 v11 = r7 & mask5 r6 = v00 | v10 r7 = v01 | v11 buf = r0[0] mem64[ input_0 + 56 ] = buf buf = r1[0] mem64[ input_0 + 120 ] = buf buf = r2[0] mem64[ input_0 + 184 ] = buf buf = r3[0] mem64[ input_0 + 248 ] = buf buf = r4[0] mem64[ input_0 + 312 ] = buf buf = r5[0] mem64[ input_0 + 376 ] = buf buf = r6[0] mem64[ input_0 + 440 ] = buf buf = r7[0] mem64[ input_0 + 504 ] = buf mask0 aligned= mem128[ MASK2_0 ] mask1 aligned= mem128[ MASK2_1 ] mask2 aligned= mem128[ MASK1_0 ] mask3 aligned= mem128[ MASK1_1 ] mask4 aligned= mem128[ MASK0_0 ] mask5 aligned= mem128[ MASK0_1 ] r0 = mem64[ input_0 + 0 ] x2 r1 = mem64[ input_0 + 8 ] x2 r2 = mem64[ input_0 + 16 ] x2 r3 = mem64[ input_0 + 24 ] x2 r4 = mem64[ input_0 + 32 ] x2 r5 = mem64[ input_0 + 40 ] x2 r6 = mem64[ input_0 + 48 ] x2 r7 = mem64[ input_0 + 56 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 0 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 16 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 32 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 48 ] = t0 r0 = mem64[ input_0 + 64 ] x2 r1 = mem64[ input_0 + 72 ] x2 r2 = mem64[ input_0 + 80 ] x2 r3 = mem64[ input_0 + 88 ] x2 r4 = mem64[ input_0 + 96 ] x2 r5 = mem64[ input_0 + 104 ] x2 r6 = mem64[ input_0 + 112 ] x2 r7 = mem64[ input_0 + 120 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 64 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 80 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 96 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 112 ] = t0 r0 = mem64[ input_0 + 128 ] x2 r1 = mem64[ input_0 + 136 ] x2 r2 = mem64[ input_0 + 144 ] x2 r3 = mem64[ input_0 + 152 ] x2 r4 = mem64[ input_0 + 160 ] x2 r5 = mem64[ input_0 + 168 ] x2 r6 = mem64[ input_0 + 176 ] x2 r7 = mem64[ input_0 + 184 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 128 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 144 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 160 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 176 ] = t0 r0 = mem64[ input_0 + 192 ] x2 r1 = mem64[ input_0 + 200 ] x2 r2 = mem64[ input_0 + 208 ] x2 r3 = mem64[ input_0 + 216 ] x2 r4 = mem64[ input_0 + 224 ] x2 r5 = mem64[ input_0 + 232 ] x2 r6 = mem64[ input_0 + 240 ] x2 r7 = mem64[ input_0 + 248 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 192 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 208 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 224 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 240 ] = t0 r0 = mem64[ input_0 + 256 ] x2 r1 = mem64[ input_0 + 264 ] x2 r2 = mem64[ input_0 + 272 ] x2 r3 = mem64[ input_0 + 280 ] x2 r4 = mem64[ input_0 + 288 ] x2 r5 = mem64[ input_0 + 296 ] x2 r6 = mem64[ input_0 + 304 ] x2 r7 = mem64[ input_0 + 312 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 256 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 272 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 288 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 304 ] = t0 r0 = mem64[ input_0 + 320 ] x2 r1 = mem64[ input_0 + 328 ] x2 r2 = mem64[ input_0 + 336 ] x2 r3 = mem64[ input_0 + 344 ] x2 r4 = mem64[ input_0 + 352 ] x2 r5 = mem64[ input_0 + 360 ] x2 r6 = mem64[ input_0 + 368 ] x2 r7 = mem64[ input_0 + 376 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 320 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 336 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 352 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 368 ] = t0 r0 = mem64[ input_0 + 384 ] x2 r1 = mem64[ input_0 + 392 ] x2 r2 = mem64[ input_0 + 400 ] x2 r3 = mem64[ input_0 + 408 ] x2 r4 = mem64[ input_0 + 416 ] x2 r5 = mem64[ input_0 + 424 ] x2 r6 = mem64[ input_0 + 432 ] x2 r7 = mem64[ input_0 + 440 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 384 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 400 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 416 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 432 ] = t0 r0 = mem64[ input_0 + 448 ] x2 r1 = mem64[ input_0 + 456 ] x2 r2 = mem64[ input_0 + 464 ] x2 r3 = mem64[ input_0 + 472 ] x2 r4 = mem64[ input_0 + 480 ] x2 r5 = mem64[ input_0 + 488 ] x2 r6 = mem64[ input_0 + 496 ] x2 r7 = mem64[ input_0 + 504 ] x2 v00 = r0 & mask0 v10 = r4 & mask0 2x v10 <<= 4 v01 = r0 & mask1 v11 = r4 & mask1 2x v01 unsigned>>= 4 r0 = v00 | v10 r4 = v01 | v11 v00 = r1 & mask0 v10 = r5 & mask0 2x v10 <<= 4 v01 = r1 & mask1 v11 = r5 & mask1 2x v01 unsigned>>= 4 r1 = v00 | v10 r5 = v01 | v11 v00 = r2 & mask0 v10 = r6 & mask0 2x v10 <<= 4 v01 = r2 & mask1 v11 = r6 & mask1 2x v01 unsigned>>= 4 r2 = v00 | v10 r6 = v01 | v11 v00 = r3 & mask0 v10 = r7 & mask0 2x v10 <<= 4 v01 = r3 & mask1 v11 = r7 & mask1 2x v01 unsigned>>= 4 r3 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask2 v10 = r2 & mask2 2x v10 <<= 2 v01 = r0 & mask3 v11 = r2 & mask3 2x v01 unsigned>>= 2 r0 = v00 | v10 r2 = v01 | v11 v00 = r1 & mask2 v10 = r3 & mask2 2x v10 <<= 2 v01 = r1 & mask3 v11 = r3 & mask3 2x v01 unsigned>>= 2 r1 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask2 v10 = r6 & mask2 2x v10 <<= 2 v01 = r4 & mask3 v11 = r6 & mask3 2x v01 unsigned>>= 2 r4 = v00 | v10 r6 = v01 | v11 v00 = r5 & mask2 v10 = r7 & mask2 2x v10 <<= 2 v01 = r5 & mask3 v11 = r7 & mask3 2x v01 unsigned>>= 2 r5 = v00 | v10 r7 = v01 | v11 v00 = r0 & mask4 v10 = r1 & mask4 2x v10 <<= 1 v01 = r0 & mask5 v11 = r1 & mask5 2x v01 unsigned>>= 1 r0 = v00 | v10 r1 = v01 | v11 v00 = r2 & mask4 v10 = r3 & mask4 2x v10 <<= 1 v01 = r2 & mask5 v11 = r3 & mask5 2x v01 unsigned>>= 1 r2 = v00 | v10 r3 = v01 | v11 v00 = r4 & mask4 v10 = r5 & mask4 2x v10 <<= 1 v01 = r4 & mask5 v11 = r5 & mask5 2x v01 unsigned>>= 1 r4 = v00 | v10 r5 = v01 | v11 v00 = r6 & mask4 v10 = r7 & mask4 2x v10 <<= 1 v01 = r6 & mask5 v11 = r7 & mask5 2x v01 unsigned>>= 1 r6 = v00 | v10 r7 = v01 | v11 t0 = r0[0]r1[0] mem128[ input_0 + 448 ] = t0 t0 = r2[0]r3[0] mem128[ input_0 + 464 ] = t0 t0 = r4[0]r5[0] mem128[ input_0 + 480 ] = t0 t0 = r6[0]r7[0] mem128[ input_0 + 496 ] = t0 return libmceliece-20230612/crypto_kem/348864/avx/uint64_sort.h0000644000000000000000000000143114441554467021026 0ustar rootroot#ifndef uint64_sort_h #define uint64_sort_h #define int64_sort CRYPTO_SHARED_NAMESPACE(int64_sort) #include #define uint64_MINMAX(a,b) \ do { \ uint64_t c = b - a; \ c >>= 63; \ c = -c; \ c &= a ^ b; \ a ^= c; \ b ^= c; \ } while(0) static void uint64_sort(uint64_t *x,long long n) { long long top,p,q,r,i; if (n < 2) return; top = 1; while (top < n - top) top += top; for (p = top;p > 0;p >>= 1) { for (i = 0;i < n - p;++i) if (!(i & p)) uint64_MINMAX(x[i],x[i+p]); i = 0; for (q = top;q > p;q >>= 1) { for (;i < n - q;++i) { if (!(i & p)) { uint64_t a = x[i + p]; for (r = q;r > p;r >>= 1) uint64_MINMAX(a,x[i+r]); x[i + p] = a; } } } } } #endif libmceliece-20230612/crypto_kem/348864/avx/update_asm.S0000644000000000000000000002107714441554467020733 0ustar rootroot// 20221231 djb: port hidden to macos; tnx thom wiggers // 20221230 djb: add linker line // linker define update_asm #include "crypto_asm_hidden.h" #define update_asm CRYPTO_SHARED_NAMESPACE(update_asm) #define _update_asm _CRYPTO_SHARED_NAMESPACE(update_asm) # qhasm: int64 input_0 # qhasm: int64 input_1 # qhasm: int64 input_2 # qhasm: int64 input_3 # qhasm: int64 input_4 # qhasm: int64 input_5 # qhasm: stack64 input_6 # qhasm: stack64 input_7 # qhasm: int64 caller_r11 # qhasm: int64 caller_r12 # qhasm: int64 caller_r13 # qhasm: int64 caller_r14 # qhasm: int64 caller_r15 # qhasm: int64 caller_rbx # qhasm: int64 caller_rbp # qhasm: int64 s0 # qhasm: int64 s1 # qhasm: enter update_asm .p2align 5 ASM_HIDDEN _update_asm ASM_HIDDEN update_asm .global _update_asm .global update_asm _update_asm: update_asm: mov %rsp,%r11 and $31,%r11 add $0,%r11 sub %r11,%rsp # qhasm: s1 = input_1 # asm 1: mov s1=int64#2 # asm 2: mov s1=%rsi mov %rsi,%rsi # qhasm: s0 = mem64[ input_0 + 0 ] # asm 1: movq 0(s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,s0=int64#4 # asm 2: movq 0(s0=%rcx movq 0(%rdi),%rcx # qhasm: s0 = (s1 s0) >> 1 # asm 1: shrd $1,>= 1 # asm 1: shr $1,> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 s0 = mem64[ input_0 + 0 ] s0 = (s1 s0) >> 1 (uint64) s1 >>= 1 mem64[ input_0 + 0 ] = s0 input_0 += input_2 return libmceliece-20230612/crypto_kem/348864/avx/util.h0000644000000000000000000000377614441554467017621 0ustar rootroot/* This file is for loading/storing data in a little-endian fashion */ #ifndef UTIL_H #define UTIL_H #include "gf.h" #include "vec128.h" #include static inline void store_i(unsigned char *out, uint64_t in, int i) { int j; for (j = 0; j < i; j++) out[j] = (in >> (j * 8)) & 0xFF; } static inline void store_gf(unsigned char *dest, gf a) { dest[0] = a & 0xFF; dest[1] = a >> 8; } static inline uint16_t load_gf(const unsigned char *src) { uint16_t a; a = src[1]; a <<= 8; a |= src[0]; return a & GFMASK; } static inline uint32_t load4(const unsigned char *src) { uint32_t a; a = src[3]; a <<= 8; a |= src[2]; a <<= 8; a |= src[1]; a <<= 8; a |= src[0]; return a; } static inline void irr_load(uint64_t * out, const unsigned char * in) { int i, j; uint16_t irr[ SYS_T + 1 ]; for (i = 0; i < SYS_T; i++) irr[i] = load_gf(in + i*2); irr[ SYS_T ] = 1; for (i = 0; i < GFBITS; i++) out[i] = 0; for (i = SYS_T; i >= 0; i--) for (j = 0; j < GFBITS; j++) { out[j] <<= 1; out[j] |= (irr[i] >> j) & 1; } } static inline void store8(unsigned char *out, uint64_t in) { out[0] = (in >> 0x00) & 0xFF; out[1] = (in >> 0x08) & 0xFF; out[2] = (in >> 0x10) & 0xFF; out[3] = (in >> 0x18) & 0xFF; out[4] = (in >> 0x20) & 0xFF; out[5] = (in >> 0x28) & 0xFF; out[6] = (in >> 0x30) & 0xFF; out[7] = (in >> 0x38) & 0xFF; } static inline uint64_t load8(const unsigned char * in) { int i; uint64_t ret = in[7]; for (i = 6; i >= 0; i--) { ret <<= 8; ret |= in[i]; } return ret; } static inline gf bitrev(gf a) { a = ((a & 0x00FF) << 8) | ((a & 0xFF00) >> 8); a = ((a & 0x0F0F) << 4) | ((a & 0xF0F0) >> 4); a = ((a & 0x3333) << 2) | ((a & 0xCCCC) >> 2); a = ((a & 0x5555) << 1) | ((a & 0xAAAA) >> 1); return a >> 4; } static inline vec128 load16(const unsigned char * in) { return vec128_set2x( load8(in), load8(in+8) ); } static inline void store16(unsigned char * out, vec128 in) { store8(out+0, vec128_extract(in, 0)); store8(out+8, vec128_extract(in, 1)); } #endif libmceliece-20230612/crypto_kem/348864/avx/vec.c0000644000000000000000000000273614441554467017407 0ustar rootroot// 20221230 djb: add linker line // linker define vec_GF_mul // linker use vec_mul_asm #include "vec.h" /* input: v, an element in GF(2^m)[y]/(y^64+y^3+y+z) in bitsliced form */ /* input: a, an element in GF(2^m)[y]/(y^64+y^3+y+z) as an array of coefficients */ /* output: out, the product of v and a in bitsliced form */ void vec_GF_mul(vec out[ GFBITS ], vec v[ GFBITS ], gf a[ SYS_T ]) { int i, j; vec buf[GFBITS][2], prod[GFBITS], tmp[GFBITS]; const vec allone = -1; // polynomial multiplication for (i = 0; i < GFBITS; i++) { buf[i][0] = 0; buf[i][1] = 0; } for (i = SYS_T-1; i >= 0; i--) { for (j = 0; j < GFBITS; j++) { buf[j][1] <<= 1; buf[j][1] |= buf[j][0] >> 63; buf[j][0] <<= 1; } vec_mul_gf(prod, v, a[i]); for (j = 0; j < GFBITS; j++) buf[j][0] ^= prod[j]; } // reduction modulo y^64 + y^3 + y + z for (i = 0; i < GFBITS; i++) prod[i] = buf[i][1] & (allone << 3); vec_mul_gf(tmp, prod, 2); for (i = 0; i < GFBITS; i++) { buf[i][1] ^= prod[i] >> (SYS_T - 3); buf[i][0] ^= prod[i] << (64 - (SYS_T - 3)); buf[i][1] ^= prod[i] >> (SYS_T - 1); buf[i][0] ^= prod[i] << (64 - (SYS_T - 1)); buf[i][0] ^= tmp[i]; } // for (i = 0; i < GFBITS; i++) prod[i] = buf[i][1] & 0x7; vec_mul_gf(tmp, prod, 2); for (i = 0; i < GFBITS; i++) { buf[i][0] ^= prod[i] << (64 - (SYS_T - 3)); buf[i][0] ^= prod[i] << (64 - (SYS_T - 1)); buf[i][0] ^= tmp[i]; } // for (i = 0; i < GFBITS; i++) out[i] = buf[i][0]; } libmceliece-20230612/crypto_kem/348864/avx/vec.h0000644000000000000000000000201014441554467017375 0ustar rootroot// 20221230 djb: changed * to [...] for vec_GF_mul declaration #ifndef VEC_H #define VEC_H #define vec_GF_mul CRYPTO_NAMESPACE(vec_GF_mul) #define vec_mul_asm CRYPTO_SHARED_NAMESPACE(vec_mul_asm) #define vec_mul_sp_asm CRYPTO_SHARED_NAMESPACE(vec_mul_sp_asm) #include "params.h" #include "gf.h" #include typedef uint64_t vec; extern void vec_mul_asm(vec *, const vec *, const vec *); static inline void vec_mul(vec *h, const vec *f, const vec *g) { vec_mul_asm(h, f, g); } extern void vec_mul_sp_asm(vec *, const vec *, const vec *); static inline void vec_mul_sp(vec *h, const vec *f, const vec *g) { vec_mul_sp_asm(h, f, g); } static inline void vec_add(vec *h, vec *f, vec *g) { int b; for (b = 0; b < GFBITS; b++) h[b] = f[b] ^ g[b]; } static inline void vec_mul_gf(vec out[ GFBITS ], vec v[ GFBITS ], gf a) { int i; vec bits[GFBITS]; for (i = 0; i < GFBITS; i++) bits[i] = -((a >> i) & 1); vec_mul_asm(out, v, bits); } void vec_GF_mul(vec [GFBITS], vec [GFBITS], gf [SYS_T]); #endif libmceliece-20230612/crypto_kem/348864/avx/vec128.h0000644000000000000000000000407414441554467017644 0ustar rootroot/* This file is for functions related to 128-bit vectors including functions for bitsliced field operations */ #ifndef VEC128_H #define VEC128_H #define vec128_mul_asm CRYPTO_SHARED_NAMESPACE(vec128_mul_asm) #define vec128_mul_GF CRYPTO_NAMESPACE(vec128_mul_GF) #include "params.h" #include #include typedef __m128i vec128; static inline vec128 vec128_set1_16b(uint16_t a) { return _mm_set1_epi16(a); } static inline vec128 vec128_setzero() { return _mm_setzero_si128(); } #define vec128_extract(a, i) ((uint64_t) _mm_extract_epi64((vec128) (a), (i))) static inline int vec128_testz(vec128 a) { return _mm_testz_si128(a, a); } static inline vec128 vec128_and(vec128 a, vec128 b) { return _mm_and_si128(a, b); } static inline vec128 vec128_xor(vec128 a, vec128 b) { return _mm_xor_si128(a, b); } static inline vec128 vec128_or(vec128 a, vec128 b) { return _mm_or_si128(a, b); } #define vec128_sll_2x(a, s) ((vec128) _mm_slli_epi64((vec128) (a), (s))) #define vec128_srl_2x(a, s) ((vec128) _mm_srli_epi64((vec128) (a), (s))) static inline vec128 vec128_set2x(uint64_t a0, uint64_t a1) { return _mm_set_epi64x(a1, a0); } static inline vec128 vec128_unpack_low(vec128 a, vec128 b) { return _mm_unpacklo_epi64(a, b); } static inline vec128 vec128_unpack_high(vec128 a, vec128 b) { return _mm_unpackhi_epi64(a, b); } static inline vec128 vec128_setbits(uint64_t a) { return _mm_set1_epi64x(-a); } static inline void vec128_copy(vec128 *dest, vec128 *src) { int i; for (i = 0; i < GFBITS; i++) dest[i] = src[i]; } static inline void vec128_add(vec128 *c, vec128 *a, vec128 *b) { int i; for (i = 0; i < GFBITS; i++) c[i] = vec128_xor(a[i], b[i]); } static inline vec128 vec128_or_reduce(vec128 * a) { int i; vec128 ret; ret = a[0]; for (i = 1; i < GFBITS; i++) ret = vec128_or(ret, a[i]); return ret; } extern void vec128_mul_asm(vec128 *, vec128 *, const vec128 *, int); /* bitsliced field multiplications */ static inline void vec128_mul(vec128 *h, vec128 *f, const vec128 *g) { vec128_mul_asm(h, f, g, 16); } #endif libmceliece-20230612/crypto_kem/348864/avx/vec128_mul_asm.S0000644000000000000000000011443514441554467021337 0ustar rootroot// 20221231 djb: port hidden to macos; tnx thom wiggers // 20221230 djb: add linker line // linker define vec128_mul_asm #include "crypto_asm_hidden.h" #define vec128_mul_asm CRYPTO_SHARED_NAMESPACE(vec128_mul_asm) #define _vec128_mul_asm _CRYPTO_SHARED_NAMESPACE(vec128_mul_asm) # qhasm: int64 input_0 # qhasm: int64 input_1 # qhasm: int64 input_2 # qhasm: int64 input_3 # qhasm: int64 input_4 # qhasm: int64 input_5 # qhasm: stack64 input_6 # qhasm: stack64 input_7 # qhasm: int64 caller_r11 # qhasm: int64 caller_r12 # qhasm: int64 caller_r13 # qhasm: int64 caller_r14 # qhasm: int64 caller_r15 # qhasm: int64 caller_rbx # qhasm: int64 caller_rbp # qhasm: reg256 b0 # qhasm: reg256 b1 # qhasm: reg256 b2 # qhasm: reg256 b3 # qhasm: reg256 b4 # qhasm: reg256 b5 # qhasm: reg256 b6 # qhasm: reg256 b7 # qhasm: reg256 b8 # qhasm: reg256 b9 # qhasm: reg256 b10 # qhasm: reg256 b11 # qhasm: reg256 a0 # qhasm: reg256 a1 # qhasm: reg256 a2 # qhasm: reg256 a3 # qhasm: reg256 a4 # qhasm: reg256 a5 # qhasm: reg256 r0 # qhasm: reg256 r1 # qhasm: reg256 r2 # qhasm: reg256 r3 # qhasm: reg256 r4 # qhasm: reg256 r5 # qhasm: reg256 r6 # qhasm: reg256 r7 # qhasm: reg256 r8 # qhasm: reg256 r9 # qhasm: reg256 r10 # qhasm: reg256 r11 # qhasm: reg256 r12 # qhasm: reg256 r13 # qhasm: reg256 r14 # qhasm: reg256 r15 # qhasm: reg256 r16 # qhasm: reg256 r17 # qhasm: reg256 r18 # qhasm: reg256 r19 # qhasm: reg256 r20 # qhasm: reg256 r21 # qhasm: reg256 r22 # qhasm: reg256 r # qhasm: reg128 h0 # qhasm: reg128 h1 # qhasm: reg128 h2 # qhasm: reg128 h3 # qhasm: reg128 h4 # qhasm: reg128 h5 # qhasm: reg128 h6 # qhasm: reg128 h7 # qhasm: reg128 h8 # qhasm: reg128 h9 # qhasm: reg128 h10 # qhasm: reg128 h11 # qhasm: reg128 h12 # qhasm: reg128 h13 # qhasm: reg128 h14 # qhasm: reg128 h15 # qhasm: reg128 h16 # qhasm: reg128 h17 # qhasm: reg128 h18 # qhasm: reg128 h19 # qhasm: reg128 h20 # qhasm: reg128 h21 # qhasm: reg128 h22 # qhasm: stack4864 buf # qhasm: int64 ptr # qhasm: int64 tmp # qhasm: enter vec128_mul_asm .p2align 5 ASM_HIDDEN _vec128_mul_asm ASM_HIDDEN vec128_mul_asm .global _vec128_mul_asm .global vec128_mul_asm _vec128_mul_asm: vec128_mul_asm: mov %rsp,%r11 and $31,%r11 add $608,%r11 sub %r11,%rsp # qhasm: ptr = &buf # asm 1: leaq ptr=int64#4 # asm 2: leaq ptr=%rcx leaq 0(%rsp),%rcx # qhasm: b11 = mem128[ input_2 + 176 ] x2 # asm 1: vbroadcasti128 176(b11=reg256#1 # asm 2: vbroadcasti128 176(b11=%ymm0 vbroadcasti128 176(%rdx), %ymm0 # qhasm: a5[0] = mem128[ input_1 + 80 ] # asm 1: vinsertf128 $0x0,80(r16=reg256#3 # asm 2: vpand r16=%ymm2 vpand %ymm0,%ymm1,%ymm2 # qhasm: mem256[ ptr + 512 ] = r16 # asm 1: vmovupd r15=reg256#4 # asm 2: vpand r15=%ymm3 vpand %ymm0,%ymm2,%ymm3 # qhasm: a3[0] = mem128[ input_1 + 48 ] # asm 1: vinsertf128 $0x0,48(r14=reg256#6 # asm 2: vpand r14=%ymm5 vpand %ymm0,%ymm4,%ymm5 # qhasm: a2[0] = mem128[ input_1 + 32 ] # asm 1: vinsertf128 $0x0,32(r13=reg256#8 # asm 2: vpand r13=%ymm7 vpand %ymm0,%ymm6,%ymm7 # qhasm: a1[0] = mem128[ input_1 + 16 ] # asm 1: vinsertf128 $0x0,16(r12=reg256#10 # asm 2: vpand r12=%ymm9 vpand %ymm0,%ymm8,%ymm9 # qhasm: a0[0] = mem128[ input_1 + 0 ] # asm 1: vinsertf128 $0x0,0(r11=reg256#1 # asm 2: vpand r11=%ymm0 vpand %ymm0,%ymm10,%ymm0 # qhasm: b10 = mem128[ input_2 + 160 ] x2 # asm 1: vbroadcasti128 160(b10=reg256#12 # asm 2: vbroadcasti128 160(b10=%ymm11 vbroadcasti128 160(%rdx), %ymm11 # qhasm: r = b10 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r15 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm2,%ymm3 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm4,%ymm3 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm6,%ymm3 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm8,%ymm3 # qhasm: r11 ^= r # asm 1: vpxor r10=reg256#4 # asm 2: vpand r10=%ymm3 vpand %ymm11,%ymm10,%ymm3 # qhasm: b9 = mem128[ input_2 + 144 ] x2 # asm 1: vbroadcasti128 144(b9=reg256#12 # asm 2: vbroadcasti128 144(b9=%ymm11 vbroadcasti128 144(%rdx), %ymm11 # qhasm: r = b9 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm2,%ymm5 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm4,%ymm5 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm6,%ymm5 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm8,%ymm5 # qhasm: r10 ^= r # asm 1: vpxor r9=reg256#6 # asm 2: vpand r9=%ymm5 vpand %ymm11,%ymm10,%ymm5 # qhasm: b8 = mem128[ input_2 + 128 ] x2 # asm 1: vbroadcasti128 128(b8=reg256#12 # asm 2: vbroadcasti128 128(b8=%ymm11 vbroadcasti128 128(%rdx), %ymm11 # qhasm: r = b8 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm2,%ymm7 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm4,%ymm7 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm6,%ymm7 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm8,%ymm7 # qhasm: r9 ^= r # asm 1: vpxor r8=reg256#8 # asm 2: vpand r8=%ymm7 vpand %ymm11,%ymm10,%ymm7 # qhasm: b7 = mem128[ input_2 + 112 ] x2 # asm 1: vbroadcasti128 112(b7=reg256#12 # asm 2: vbroadcasti128 112(b7=%ymm11 vbroadcasti128 112(%rdx), %ymm11 # qhasm: r = b7 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm2,%ymm9 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm4,%ymm9 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm6,%ymm9 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm8,%ymm9 # qhasm: r8 ^= r # asm 1: vpxor r7=reg256#10 # asm 2: vpand r7=%ymm9 vpand %ymm11,%ymm10,%ymm9 # qhasm: b6 = mem128[ input_2 + 96 ] x2 # asm 1: vbroadcasti128 96(b6=reg256#12 # asm 2: vbroadcasti128 96(b6=%ymm11 vbroadcasti128 96(%rdx), %ymm11 # qhasm: r = b6 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm2,%ymm0 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm4,%ymm0 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm6,%ymm0 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm8,%ymm0 # qhasm: r7 ^= r # asm 1: vpxor r6=reg256#1 # asm 2: vpand r6=%ymm0 vpand %ymm11,%ymm10,%ymm0 # qhasm: b5 = mem128[ input_2 + 80 ] x2 # asm 1: vbroadcasti128 80(b5=reg256#12 # asm 2: vbroadcasti128 80(b5=%ymm11 vbroadcasti128 80(%rdx), %ymm11 # qhasm: r = b5 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm2,%ymm3 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm4,%ymm3 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm6,%ymm3 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#4 # asm 2: vpand r=%ymm3 vpand %ymm11,%ymm8,%ymm3 # qhasm: r6 ^= r # asm 1: vpxor r5=reg256#4 # asm 2: vpand r5=%ymm3 vpand %ymm11,%ymm10,%ymm3 # qhasm: b4 = mem128[ input_2 + 64 ] x2 # asm 1: vbroadcasti128 64(b4=reg256#12 # asm 2: vbroadcasti128 64(b4=%ymm11 vbroadcasti128 64(%rdx), %ymm11 # qhasm: r = b4 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm2,%ymm5 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm4,%ymm5 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm6,%ymm5 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#6 # asm 2: vpand r=%ymm5 vpand %ymm11,%ymm8,%ymm5 # qhasm: r5 ^= r # asm 1: vpxor r4=reg256#6 # asm 2: vpand r4=%ymm5 vpand %ymm11,%ymm10,%ymm5 # qhasm: b3 = mem128[ input_2 + 48 ] x2 # asm 1: vbroadcasti128 48(b3=reg256#12 # asm 2: vbroadcasti128 48(b3=%ymm11 vbroadcasti128 48(%rdx), %ymm11 # qhasm: r = b3 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm2,%ymm7 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm4,%ymm7 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm6,%ymm7 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#8 # asm 2: vpand r=%ymm7 vpand %ymm11,%ymm8,%ymm7 # qhasm: r4 ^= r # asm 1: vpxor r3=reg256#8 # asm 2: vpand r3=%ymm7 vpand %ymm11,%ymm10,%ymm7 # qhasm: b2 = mem128[ input_2 + 32 ] x2 # asm 1: vbroadcasti128 32(b2=reg256#12 # asm 2: vbroadcasti128 32(b2=%ymm11 vbroadcasti128 32(%rdx), %ymm11 # qhasm: r = b2 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm2,%ymm9 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm4,%ymm9 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm6,%ymm9 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#10 # asm 2: vpand r=%ymm9 vpand %ymm11,%ymm8,%ymm9 # qhasm: r3 ^= r # asm 1: vpxor r2=reg256#10 # asm 2: vpand r2=%ymm9 vpand %ymm11,%ymm10,%ymm9 # qhasm: b1 = mem128[ input_2 + 16 ] x2 # asm 1: vbroadcasti128 16(b1=reg256#12 # asm 2: vbroadcasti128 16(b1=%ymm11 vbroadcasti128 16(%rdx), %ymm11 # qhasm: r = b1 & a5 # asm 1: vpand r=reg256#13 # asm 2: vpand r=%ymm12 vpand %ymm11,%ymm1,%ymm12 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm2,%ymm0 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm4,%ymm0 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm6,%ymm0 # qhasm: r3 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm11,%ymm8,%ymm0 # qhasm: r2 ^= r # asm 1: vpxor r1=reg256#1 # asm 2: vpand r1=%ymm0 vpand %ymm11,%ymm10,%ymm0 # qhasm: b0 = mem128[ input_2 + 0 ] x2 # asm 1: vbroadcasti128 0(b0=reg256#12 # asm 2: vbroadcasti128 0(b0=%ymm11 vbroadcasti128 0(%rdx), %ymm11 # qhasm: r = b0 & a5 # asm 1: vpand r=reg256#2 # asm 2: vpand r=%ymm1 vpand %ymm11,%ymm1,%ymm1 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#2 # asm 2: vpand r=%ymm1 vpand %ymm11,%ymm2,%ymm1 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#2 # asm 2: vpand r=%ymm1 vpand %ymm11,%ymm4,%ymm1 # qhasm: r3 ^= r # asm 1: vpxor r=reg256#2 # asm 2: vpand r=%ymm1 vpand %ymm11,%ymm6,%ymm1 # qhasm: r2 ^= r # asm 1: vpxor r=reg256#2 # asm 2: vpand r=%ymm1 vpand %ymm11,%ymm8,%ymm1 # qhasm: r1 ^= r # asm 1: vpxor r0=reg256#2 # asm 2: vpand r0=%ymm1 vpand %ymm11,%ymm10,%ymm1 # qhasm: mem256[ ptr + 128 ] = r4 # asm 1: vmovupd h22=reg128#1 # asm 2: movdqu 528(h22=%xmm0 movdqu 528(%rcx),%xmm0 # qhasm: h13 = h22 # asm 1: movdqa h13=reg128#2 # asm 2: movdqa h13=%xmm1 movdqa %xmm0,%xmm1 # qhasm: h10 = h22 # asm 1: movdqa h10=reg128#1 # asm 2: movdqa h10=%xmm0 movdqa %xmm0,%xmm0 # qhasm: h21 = mem128[ ptr + 496 ] # asm 1: movdqu 496(h21=reg128#3 # asm 2: movdqu 496(h21=%xmm2 movdqu 496(%rcx),%xmm2 # qhasm: h12 = h21 # asm 1: movdqa h12=reg128#4 # asm 2: movdqa h12=%xmm3 movdqa %xmm2,%xmm3 # qhasm: h9 = h21 # asm 1: movdqa h9=reg128#3 # asm 2: movdqa h9=%xmm2 movdqa %xmm2,%xmm2 # qhasm: h20 = mem128[ ptr + 464 ] # asm 1: movdqu 464(h20=reg128#5 # asm 2: movdqu 464(h20=%xmm4 movdqu 464(%rcx),%xmm4 # qhasm: h11 = h20 # asm 1: movdqa h11=reg128#6 # asm 2: movdqa h11=%xmm5 movdqa %xmm4,%xmm5 # qhasm: h8 = h20 # asm 1: movdqa h8=reg128#5 # asm 2: movdqa h8=%xmm4 movdqa %xmm4,%xmm4 # qhasm: h19 = mem128[ ptr + 432 ] # asm 1: movdqu 432(h19=reg128#7 # asm 2: movdqu 432(h19=%xmm6 movdqu 432(%rcx),%xmm6 # qhasm: h10 = h10 ^ h19 # asm 1: vpxor h10=reg128#1 # asm 2: vpxor h10=%xmm0 vpxor %xmm6,%xmm0,%xmm0 # qhasm: h7 = h19 # asm 1: movdqa h7=reg128#7 # asm 2: movdqa h7=%xmm6 movdqa %xmm6,%xmm6 # qhasm: h18 = mem128[ ptr + 400 ] # asm 1: movdqu 400(h18=reg128#8 # asm 2: movdqu 400(h18=%xmm7 movdqu 400(%rcx),%xmm7 # qhasm: h9 = h9 ^ h18 # asm 1: vpxor h9=reg128#3 # asm 2: vpxor h9=%xmm2 vpxor %xmm7,%xmm2,%xmm2 # qhasm: h6 = h18 # asm 1: movdqa h6=reg128#8 # asm 2: movdqa h6=%xmm7 movdqa %xmm7,%xmm7 # qhasm: h17 = mem128[ ptr + 368 ] # asm 1: movdqu 368(h17=reg128#9 # asm 2: movdqu 368(h17=%xmm8 movdqu 368(%rcx),%xmm8 # qhasm: h8 = h8 ^ h17 # asm 1: vpxor h8=reg128#5 # asm 2: vpxor h8=%xmm4 vpxor %xmm8,%xmm4,%xmm4 # qhasm: h5 = h17 # asm 1: movdqa h5=reg128#9 # asm 2: movdqa h5=%xmm8 movdqa %xmm8,%xmm8 # qhasm: h16 = mem128[ ptr + 336 ] # asm 1: movdqu 336(h16=reg128#10 # asm 2: movdqu 336(h16=%xmm9 movdqu 336(%rcx),%xmm9 # qhasm: h16 = h16 ^ mem128[ ptr + 512 ] # asm 1: vpxor 512(h16=reg128#10 # asm 2: vpxor 512(h16=%xmm9 vpxor 512(%rcx),%xmm9,%xmm9 # qhasm: h7 = h7 ^ h16 # asm 1: vpxor h7=reg128#7 # asm 2: vpxor h7=%xmm6 vpxor %xmm9,%xmm6,%xmm6 # qhasm: h4 = h16 # asm 1: movdqa h4=reg128#10 # asm 2: movdqa h4=%xmm9 movdqa %xmm9,%xmm9 # qhasm: h15 = mem128[ ptr + 304 ] # asm 1: movdqu 304(h15=reg128#11 # asm 2: movdqu 304(h15=%xmm10 movdqu 304(%rcx),%xmm10 # qhasm: h15 = h15 ^ mem128[ ptr + 480 ] # asm 1: vpxor 480(h15=reg128#11 # asm 2: vpxor 480(h15=%xmm10 vpxor 480(%rcx),%xmm10,%xmm10 # qhasm: h6 = h6 ^ h15 # asm 1: vpxor h6=reg128#8 # asm 2: vpxor h6=%xmm7 vpxor %xmm10,%xmm7,%xmm7 # qhasm: h3 = h15 # asm 1: movdqa h3=reg128#11 # asm 2: movdqa h3=%xmm10 movdqa %xmm10,%xmm10 # qhasm: h14 = mem128[ ptr + 272 ] # asm 1: movdqu 272(h14=reg128#12 # asm 2: movdqu 272(h14=%xmm11 movdqu 272(%rcx),%xmm11 # qhasm: h14 = h14 ^ mem128[ ptr + 448 ] # asm 1: vpxor 448(h14=reg128#12 # asm 2: vpxor 448(h14=%xmm11 vpxor 448(%rcx),%xmm11,%xmm11 # qhasm: h5 = h5 ^ h14 # asm 1: vpxor h5=reg128#9 # asm 2: vpxor h5=%xmm8 vpxor %xmm11,%xmm8,%xmm8 # qhasm: h2 = h14 # asm 1: movdqa h2=reg128#12 # asm 2: movdqa h2=%xmm11 movdqa %xmm11,%xmm11 # qhasm: h13 = h13 ^ mem128[ ptr + 240 ] # asm 1: vpxor 240(h13=reg128#2 # asm 2: vpxor 240(h13=%xmm1 vpxor 240(%rcx),%xmm1,%xmm1 # qhasm: h13 = h13 ^ mem128[ ptr + 416 ] # asm 1: vpxor 416(h13=reg128#2 # asm 2: vpxor 416(h13=%xmm1 vpxor 416(%rcx),%xmm1,%xmm1 # qhasm: h4 = h4 ^ h13 # asm 1: vpxor h4=reg128#10 # asm 2: vpxor h4=%xmm9 vpxor %xmm1,%xmm9,%xmm9 # qhasm: h1 = h13 # asm 1: movdqa h1=reg128#2 # asm 2: movdqa h1=%xmm1 movdqa %xmm1,%xmm1 # qhasm: h12 = h12 ^ mem128[ ptr + 208 ] # asm 1: vpxor 208(h12=reg128#4 # asm 2: vpxor 208(h12=%xmm3 vpxor 208(%rcx),%xmm3,%xmm3 # qhasm: h12 = h12 ^ mem128[ ptr + 384 ] # asm 1: vpxor 384(h12=reg128#4 # asm 2: vpxor 384(h12=%xmm3 vpxor 384(%rcx),%xmm3,%xmm3 # qhasm: h3 = h3 ^ h12 # asm 1: vpxor h3=reg128#11 # asm 2: vpxor h3=%xmm10 vpxor %xmm3,%xmm10,%xmm10 # qhasm: h0 = h12 # asm 1: movdqa h0=reg128#4 # asm 2: movdqa h0=%xmm3 movdqa %xmm3,%xmm3 # qhasm: h11 = h11 ^ mem128[ ptr + 352 ] # asm 1: vpxor 352(h11=reg128#6 # asm 2: vpxor 352(h11=%xmm5 vpxor 352(%rcx),%xmm5,%xmm5 # qhasm: h11 = h11 ^ mem128[ ptr + 176 ] # asm 1: vpxor 176(h11=reg128#6 # asm 2: vpxor 176(h11=%xmm5 vpxor 176(%rcx),%xmm5,%xmm5 # qhasm: mem128[ input_0 + 176 ] = h11 # asm 1: movdqu h10=reg128#1 # asm 2: vpxor 320(h10=%xmm0 vpxor 320(%rcx),%xmm0,%xmm0 # qhasm: h10 = h10 ^ mem128[ ptr + 144 ] # asm 1: vpxor 144(h10=reg128#1 # asm 2: vpxor 144(h10=%xmm0 vpxor 144(%rcx),%xmm0,%xmm0 # qhasm: mem128[ input_0 + 160 ] = h10 # asm 1: movdqu h9=reg128#1 # asm 2: vpxor 288(h9=%xmm0 vpxor 288(%rcx),%xmm2,%xmm0 # qhasm: h9 = h9 ^ mem128[ ptr + 112 ] # asm 1: vpxor 112(h9=reg128#1 # asm 2: vpxor 112(h9=%xmm0 vpxor 112(%rcx),%xmm0,%xmm0 # qhasm: mem128[ input_0 + 144 ] = h9 # asm 1: movdqu h8=reg128#1 # asm 2: vpxor 256(h8=%xmm0 vpxor 256(%rcx),%xmm4,%xmm0 # qhasm: h8 = h8 ^ mem128[ ptr + 80 ] # asm 1: vpxor 80(h8=reg128#1 # asm 2: vpxor 80(h8=%xmm0 vpxor 80(%rcx),%xmm0,%xmm0 # qhasm: mem128[ input_0 + 128 ] = h8 # asm 1: movdqu h7=reg128#1 # asm 2: vpxor 224(h7=%xmm0 vpxor 224(%rcx),%xmm6,%xmm0 # qhasm: h7 = h7 ^ mem128[ ptr + 48 ] # asm 1: vpxor 48(h7=reg128#1 # asm 2: vpxor 48(h7=%xmm0 vpxor 48(%rcx),%xmm0,%xmm0 # qhasm: mem128[ input_0 + 112 ] = h7 # asm 1: movdqu h6=reg128#1 # asm 2: vpxor 192(h6=%xmm0 vpxor 192(%rcx),%xmm7,%xmm0 # qhasm: h6 = h6 ^ mem128[ ptr + 16 ] # asm 1: vpxor 16(h6=reg128#1 # asm 2: vpxor 16(h6=%xmm0 vpxor 16(%rcx),%xmm0,%xmm0 # qhasm: mem128[ input_0 + 96 ] = h6 # asm 1: movdqu h5=reg128#1 # asm 2: vpxor 160(h5=%xmm0 vpxor 160(%rcx),%xmm8,%xmm0 # qhasm: mem128[ input_0 + 80 ] = h5 # asm 1: movdqu h4=reg128#1 # asm 2: vpxor 128(h4=%xmm0 vpxor 128(%rcx),%xmm9,%xmm0 # qhasm: mem128[ input_0 + 64 ] = h4 # asm 1: movdqu h3=reg128#1 # asm 2: vpxor 96(h3=%xmm0 vpxor 96(%rcx),%xmm10,%xmm0 # qhasm: mem128[ input_0 + 48 ] = h3 # asm 1: movdqu h2=reg128#1 # asm 2: vpxor 64(h2=%xmm0 vpxor 64(%rcx),%xmm11,%xmm0 # qhasm: mem128[ input_0 + 32 ] = h2 # asm 1: movdqu h1=reg128#1 # asm 2: vpxor 32(h1=%xmm0 vpxor 32(%rcx),%xmm1,%xmm0 # qhasm: mem128[ input_0 + 16 ] = h1 # asm 1: movdqu h0=reg128#1 # asm 2: vpxor 0(h0=%xmm0 vpxor 0(%rcx),%xmm3,%xmm0 # qhasm: mem128[ input_0 + 0 ] = h0 # asm 1: movdqu typedef __m256i vec256; static inline vec256 vec256_set1_16b(uint16_t a) { return _mm256_set1_epi16(a); } static inline vec256 vec256_set1_32b(uint64_t a) { return _mm256_set1_epi32(a); } static inline vec256 vec256_setzero() { return _mm256_setzero_si256(); } static inline vec256 vec256_set4x(uint64_t a0, uint64_t a1, uint64_t a2, uint64_t a3) { return _mm256_set_epi64x(a3, a2, a1, a0); } #define vec256_extract2x(a,i) ((vec128) _mm256_extractf128_si256((vec256) (a),(i))) #define vec256_extract(a,i) ((uint64_t) _mm256_extract_epi64((vec256) (a),(i))) static inline int vec256_testz(vec256 a) { return _mm256_testz_si256(a, a); } static inline vec256 vec256_and(vec256 a, vec256 b) { return _mm256_and_si256(a, b); } static inline vec256 vec256_xor(vec256 a, vec256 b) { return _mm256_xor_si256(a, b); } static inline vec256 vec256_or(vec256 a, vec256 b) { return _mm256_or_si256(a, b); } #define vec256_sll_4x(a, s) ((vec256) _mm256_slli_epi64((vec256) (a), (s))) #define vec256_srl_4x(a, s) ((vec256) _mm256_srli_epi64((vec256) (a), (s))) static inline vec256 vec256_unpack_low(vec256 a, vec256 b) { return _mm256_permute2x128_si256 (a, b, 0x20); } static inline vec256 vec256_unpack_high(vec256 a, vec256 b) { return _mm256_permute2x128_si256 (a, b, 0x31); } static inline vec256 vec256_unpack_low_2x(vec256 a, vec256 b) { return _mm256_unpacklo_epi64 (a, b); } static inline vec256 vec256_unpack_high_2x(vec256 a, vec256 b) { return _mm256_unpackhi_epi64 (a, b); } static inline vec256 vec256_or_reduce(vec256 * a) { int i; vec256 ret; ret = a[0]; for (i = 1; i < GFBITS; i++) ret = vec256_or(ret, a[i]); return ret; } static inline void vec256_copy(vec256 *dest, vec256 *src) { int i; for (i = 0; i < GFBITS; i++) dest[i] = src[i]; } extern void vec256_mul_asm(vec256 *, vec256 *, const vec256 *); /* bitsliced field multiplications */ static inline void vec256_mul(vec256 *h, vec256 *f, const vec256 *g) { vec256_mul_asm(h, f, g); } void vec256_sq(vec256 *, vec256 *); void vec256_inv(vec256 *, vec256 *); extern void vec256_maa_asm(vec256 *, vec256 *, const vec256 *); extern void vec256_ama_asm(vec256 *, vec256 *, const vec256 *); #endif libmceliece-20230612/crypto_kem/348864/avx/vec256_mul_asm.S0000644000000000000000000015327114441554467021342 0ustar rootroot// 20221231 djb: port hidden to macos; tnx thom wiggers // 20221230 djb: add linker line // linker define vec256_mul_asm #include "crypto_asm_hidden.h" #define vec256_mul_asm CRYPTO_SHARED_NAMESPACE(vec256_mul_asm) #define _vec256_mul_asm _CRYPTO_SHARED_NAMESPACE(vec256_mul_asm) # qhasm: int64 input_0 # qhasm: int64 input_1 # qhasm: int64 input_2 # qhasm: int64 input_3 # qhasm: int64 input_4 # qhasm: int64 input_5 # qhasm: stack64 input_6 # qhasm: stack64 input_7 # qhasm: int64 caller_r11 # qhasm: int64 caller_r12 # qhasm: int64 caller_r13 # qhasm: int64 caller_r14 # qhasm: int64 caller_r15 # qhasm: int64 caller_rbx # qhasm: int64 caller_rbp # qhasm: reg256 a0 # qhasm: reg256 a1 # qhasm: reg256 a2 # qhasm: reg256 a3 # qhasm: reg256 a4 # qhasm: reg256 a5 # qhasm: reg256 a6 # qhasm: reg256 a7 # qhasm: reg256 a8 # qhasm: reg256 a9 # qhasm: reg256 a10 # qhasm: reg256 a11 # qhasm: reg256 b0 # qhasm: reg256 b1 # qhasm: reg256 r0 # qhasm: reg256 r1 # qhasm: reg256 r2 # qhasm: reg256 r3 # qhasm: reg256 r4 # qhasm: reg256 r5 # qhasm: reg256 r6 # qhasm: reg256 r7 # qhasm: reg256 r8 # qhasm: reg256 r9 # qhasm: reg256 r10 # qhasm: reg256 r11 # qhasm: reg256 r12 # qhasm: reg256 r13 # qhasm: reg256 r14 # qhasm: reg256 r15 # qhasm: reg256 r16 # qhasm: reg256 r17 # qhasm: reg256 r18 # qhasm: reg256 r19 # qhasm: reg256 r20 # qhasm: reg256 r21 # qhasm: reg256 r22 # qhasm: reg256 r # qhasm: enter vec256_mul_asm .p2align 5 ASM_HIDDEN _vec256_mul_asm ASM_HIDDEN vec256_mul_asm .global _vec256_mul_asm .global vec256_mul_asm _vec256_mul_asm: vec256_mul_asm: mov %rsp,%r11 and $31,%r11 add $0,%r11 sub %r11,%rsp # qhasm: b0 = mem256[ input_2 + 0 ] # asm 1: vmovupd 0(b0=reg256#1 # asm 2: vmovupd 0(b0=%ymm0 vmovupd 0(%rdx),%ymm0 # qhasm: a11 = mem256[ input_1 + 352 ] # asm 1: vmovupd 352(a11=reg256#2 # asm 2: vmovupd 352(a11=%ymm1 vmovupd 352(%rsi),%ymm1 # qhasm: r11 = a11 & b0 # asm 1: vpand r11=reg256#3 # asm 2: vpand r11=%ymm2 vpand %ymm1,%ymm0,%ymm2 # qhasm: r12 = a11 & mem256[input_2 + 32] # asm 1: vpand 32(r12=reg256#4 # asm 2: vpand 32(r12=%ymm3 vpand 32(%rdx),%ymm1,%ymm3 # qhasm: r13 = a11 & mem256[input_2 + 64] # asm 1: vpand 64(r13=reg256#5 # asm 2: vpand 64(r13=%ymm4 vpand 64(%rdx),%ymm1,%ymm4 # qhasm: r14 = a11 & mem256[input_2 + 96] # asm 1: vpand 96(r14=reg256#6 # asm 2: vpand 96(r14=%ymm5 vpand 96(%rdx),%ymm1,%ymm5 # qhasm: r15 = a11 & mem256[input_2 + 128] # asm 1: vpand 128(r15=reg256#7 # asm 2: vpand 128(r15=%ymm6 vpand 128(%rdx),%ymm1,%ymm6 # qhasm: r16 = a11 & mem256[input_2 + 160] # asm 1: vpand 160(r16=reg256#8 # asm 2: vpand 160(r16=%ymm7 vpand 160(%rdx),%ymm1,%ymm7 # qhasm: r17 = a11 & mem256[input_2 + 192] # asm 1: vpand 192(r17=reg256#9 # asm 2: vpand 192(r17=%ymm8 vpand 192(%rdx),%ymm1,%ymm8 # qhasm: r18 = a11 & mem256[input_2 + 224] # asm 1: vpand 224(r18=reg256#10 # asm 2: vpand 224(r18=%ymm9 vpand 224(%rdx),%ymm1,%ymm9 # qhasm: r19 = a11 & mem256[input_2 + 256] # asm 1: vpand 256(r19=reg256#11 # asm 2: vpand 256(r19=%ymm10 vpand 256(%rdx),%ymm1,%ymm10 # qhasm: r20 = a11 & mem256[input_2 + 288] # asm 1: vpand 288(r20=reg256#12 # asm 2: vpand 288(r20=%ymm11 vpand 288(%rdx),%ymm1,%ymm11 # qhasm: r21 = a11 & mem256[input_2 + 320] # asm 1: vpand 320(r21=reg256#13 # asm 2: vpand 320(r21=%ymm12 vpand 320(%rdx),%ymm1,%ymm12 # qhasm: r22 = a11 & mem256[input_2 + 352] # asm 1: vpand 352(r22=reg256#2 # asm 2: vpand 352(r22=%ymm1 vpand 352(%rdx),%ymm1,%ymm1 # qhasm: r13 ^= r22 # asm 1: vpxor r10=reg256#2 # asm 2: vmovapd r10=%ymm1 vmovapd %ymm1,%ymm1 # qhasm: a10 = mem256[ input_1 + 320 ] # asm 1: vmovupd 320(a10=reg256#14 # asm 2: vmovupd 320(a10=%ymm13 vmovupd 320(%rsi),%ymm13 # qhasm: r = a10 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r15 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r16 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r17 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r18 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r19 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r20 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r21 ^= r # asm 1: vpxor r9=reg256#13 # asm 2: vmovapd r9=%ymm12 vmovapd %ymm12,%ymm12 # qhasm: a9 = mem256[ input_1 + 288 ] # asm 1: vmovupd 288(a9=reg256#14 # asm 2: vmovupd 288(a9=%ymm13 vmovupd 288(%rsi),%ymm13 # qhasm: r = a9 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r15 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r16 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r17 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r18 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r19 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r20 ^= r # asm 1: vpxor r8=reg256#12 # asm 2: vmovapd r8=%ymm11 vmovapd %ymm11,%ymm11 # qhasm: a8 = mem256[ input_1 + 256 ] # asm 1: vmovupd 256(a8=reg256#14 # asm 2: vmovupd 256(a8=%ymm13 vmovupd 256(%rsi),%ymm13 # qhasm: r = a8 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r15 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r16 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r17 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r18 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r19 ^= r # asm 1: vpxor r7=reg256#11 # asm 2: vmovapd r7=%ymm10 vmovapd %ymm10,%ymm10 # qhasm: a7 = mem256[ input_1 + 224 ] # asm 1: vmovupd 224(a7=reg256#14 # asm 2: vmovupd 224(a7=%ymm13 vmovupd 224(%rsi),%ymm13 # qhasm: r = a7 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r15 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r16 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r17 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r18 ^= r # asm 1: vpxor r6=reg256#10 # asm 2: vmovapd r6=%ymm9 vmovapd %ymm9,%ymm9 # qhasm: a6 = mem256[ input_1 + 192 ] # asm 1: vmovupd 192(a6=reg256#14 # asm 2: vmovupd 192(a6=%ymm13 vmovupd 192(%rsi),%ymm13 # qhasm: r = a6 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r15 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r16 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r17 ^= r # asm 1: vpxor r5=reg256#9 # asm 2: vmovapd r5=%ymm8 vmovapd %ymm8,%ymm8 # qhasm: a5 = mem256[ input_1 + 160 ] # asm 1: vmovupd 160(a5=reg256#14 # asm 2: vmovupd 160(a5=%ymm13 vmovupd 160(%rsi),%ymm13 # qhasm: r = a5 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r15 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r16 ^= r # asm 1: vpxor r4=reg256#8 # asm 2: vmovapd r4=%ymm7 vmovapd %ymm7,%ymm7 # qhasm: a4 = mem256[ input_1 + 128 ] # asm 1: vmovupd 128(a4=reg256#14 # asm 2: vmovupd 128(a4=%ymm13 vmovupd 128(%rsi),%ymm13 # qhasm: r = a4 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r14 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r15 ^= r # asm 1: vpxor r3=reg256#7 # asm 2: vmovapd r3=%ymm6 vmovapd %ymm6,%ymm6 # qhasm: a3 = mem256[ input_1 + 96 ] # asm 1: vmovupd 96(a3=reg256#14 # asm 2: vmovupd 96(a3=%ymm13 vmovupd 96(%rsi),%ymm13 # qhasm: r = a3 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r3 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r13 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r14 ^= r # asm 1: vpxor r2=reg256#6 # asm 2: vmovapd r2=%ymm5 vmovapd %ymm5,%ymm5 # qhasm: a2 = mem256[ input_1 + 64 ] # asm 1: vmovupd 64(a2=reg256#14 # asm 2: vmovupd 64(a2=%ymm13 vmovupd 64(%rsi),%ymm13 # qhasm: r = a2 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r2 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r3 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r12 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r13 ^= r # asm 1: vpxor r1=reg256#5 # asm 2: vmovapd r1=%ymm4 vmovapd %ymm4,%ymm4 # qhasm: a1 = mem256[ input_1 + 32 ] # asm 1: vmovupd 32(a1=reg256#14 # asm 2: vmovupd 32(a1=%ymm13 vmovupd 32(%rsi),%ymm13 # qhasm: r = a1 & b0 # asm 1: vpand r=reg256#15 # asm 2: vpand r=%ymm14 vpand %ymm13,%ymm0,%ymm14 # qhasm: r1 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 32(r=%ymm14 vpand 32(%rdx),%ymm13,%ymm14 # qhasm: r2 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 64(r=%ymm14 vpand 64(%rdx),%ymm13,%ymm14 # qhasm: r3 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 96(r=%ymm14 vpand 96(%rdx),%ymm13,%ymm14 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 128(r=%ymm14 vpand 128(%rdx),%ymm13,%ymm14 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 160(r=%ymm14 vpand 160(%rdx),%ymm13,%ymm14 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 192(r=%ymm14 vpand 192(%rdx),%ymm13,%ymm14 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 224(r=%ymm14 vpand 224(%rdx),%ymm13,%ymm14 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 256(r=%ymm14 vpand 256(%rdx),%ymm13,%ymm14 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 288(r=%ymm14 vpand 288(%rdx),%ymm13,%ymm14 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#15 # asm 2: vpand 320(r=%ymm14 vpand 320(%rdx),%ymm13,%ymm14 # qhasm: r11 ^= r # asm 1: vpxor r=reg256#14 # asm 2: vpand 352(r=%ymm13 vpand 352(%rdx),%ymm13,%ymm13 # qhasm: r12 ^= r # asm 1: vpxor r0=reg256#4 # asm 2: vmovapd r0=%ymm3 vmovapd %ymm3,%ymm3 # qhasm: a0 = mem256[ input_1 + 0 ] # asm 1: vmovupd 0(a0=reg256#14 # asm 2: vmovupd 0(a0=%ymm13 vmovupd 0(%rsi),%ymm13 # qhasm: r = a0 & b0 # asm 1: vpand r=reg256#1 # asm 2: vpand r=%ymm0 vpand %ymm13,%ymm0,%ymm0 # qhasm: r0 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 32(r=%ymm0 vpand 32(%rdx),%ymm13,%ymm0 # qhasm: r1 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 64(r=%ymm0 vpand 64(%rdx),%ymm13,%ymm0 # qhasm: r2 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 96(r=%ymm0 vpand 96(%rdx),%ymm13,%ymm0 # qhasm: r3 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 128(r=%ymm0 vpand 128(%rdx),%ymm13,%ymm0 # qhasm: r4 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 160(r=%ymm0 vpand 160(%rdx),%ymm13,%ymm0 # qhasm: r5 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 192(r=%ymm0 vpand 192(%rdx),%ymm13,%ymm0 # qhasm: r6 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 224(r=%ymm0 vpand 224(%rdx),%ymm13,%ymm0 # qhasm: r7 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 256(r=%ymm0 vpand 256(%rdx),%ymm13,%ymm0 # qhasm: r8 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 288(r=%ymm0 vpand 288(%rdx),%ymm13,%ymm0 # qhasm: r9 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 320(r=%ymm0 vpand 320(%rdx),%ymm13,%ymm0 # qhasm: r10 ^= r # asm 1: vpxor r=reg256#1 # asm 2: vpand 352(r=%ymm0 vpand 352(%rdx),%ymm13,%ymm0 # qhasm: r11 ^= r # asm 1: vpxor