From e785891fb155c1ae9739f4325f2de08a36f7fd15 Mon Sep 17 00:00:00 2001 From: Sy Date: Thu, 7 May 2020 16:28:01 +0200 Subject: [PATCH] integration of the generated file (nrLDPC_cnProc_BG1_Z384_13 with the LDPC decoder at the base --- cmake_targets/CMakeLists.txt | 4 + .../CODING/nrLDPC_decoder/nrLDPC_decoder.c | 28 +- .../nrLDPC_decoder/nrLDPC_tools/Makefile | 6 +- .../nrLDPC_tools/cnProc_gen.exe | Bin 0 -> 361326 bytes .../nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h | 5 +- .../nrLDPC_decoder/nrLDPC_tools/cnProc_gen.o | Bin 0 -> 117158 bytes .../nrLDPC_decoder/nrLDPC_tools/gmon.out | Bin 0 -> 4562 bytes .../nrLDPC_cnProc_BG1_Z384_13.c | 100831 +++++++++++++++ .../nrLDPC_cnProc_BG1_Z384_13.h | 4 + .../CODING/nrLDPC_decoder/nrLDPC_tools/main.c | 2 +- .../CODING/nrLDPC_decoder/nrLDPC_tools/main.o | Bin 0 -> 206488 bytes .../PHY/CODING/nrLDPC_decoder/nrLDPC_types.h | 2 +- openair1/PHY/TOOLS/time_meas.h | 4 +- 13 files changed, 100869 insertions(+), 17 deletions(-) create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.exe create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.o create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/gmon.out create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.o diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt index eab3d5a068..d31dde0338 100644 --- a/cmake_targets/CMakeLists.txt +++ b/cmake_targets/CMakeLists.txt @@ -1305,19 +1305,23 @@ set(PHY_TURBOIF set(PHY_LDPC_ORIG_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder.c + ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c ) set(PHY_LDPC_OPTIM_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim.c + ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c ) set(PHY_LDPC_OPTIM8SEG_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim8seg.c + ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c ) set(PHY_LDPC_OPTIM8SEGMULTI_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim8segmulti.c + ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c ) set(PHY_NR_CODINGIF ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_load.c; diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c index 785b588b9f..b62d1b00e7 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c @@ -1,3 +1,4 @@ + /* * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more * contributor license agreements. See the NOTICE file distributed with @@ -37,7 +38,7 @@ #include "nrLDPC_mPass.h" #include "nrLDPC_cnProc.h" #include "nrLDPC_bnProc.h" - +#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h" #define NR_LDPC_ENABLE_PARITY_CHECK #define NR_LDPC_PROFILER_DETAIL @@ -80,6 +81,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP uint8_t BG = p_decParams->BG; uint8_t numMaxIter = p_decParams->numMaxIter; e_nrLDPC_outMode outMode = p_decParams->outMode; + + int8_t* cnProcBuf= p_procBuf->cnProcBuf; + int8_t* cnProcBufRes=p_procBuf->cnProcBufRes; // Minimum number of iterations is 1 // 0 iterations means hard-decision on input LLRs @@ -142,9 +146,12 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP start_meas(&p_profiler->cnProc); #endif if (BG == 1) - { + { if(Z==384){ + nrLDPC_cnProc_BG1_Z384_13(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + }else{ nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z); - } + } +} else { nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); @@ -242,8 +249,12 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP #endif if (BG == 1) { + if(Z==384){ + nrLDPC_cnProc_BG1_Z384_13(p_procBuf->cnProcBuf, p_procBuf->cnProcBufRes); + }else{ nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z); - } + } + } else { nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); @@ -351,9 +362,12 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP start_meas(&p_profiler->cnProc); #endif if (BG == 1) - { - nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z); - } + { if(Z==384){ + nrLDPC_cnProc_BG1_Z384_13(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + }else{ + nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z); + } + } else { nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/Makefile b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/Makefile index 87dacb5a77..93e59d2635 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/Makefile +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/Makefile @@ -1,5 +1,5 @@ C=gcc -CFLAGS=-W -Wall -mavx2 +CFLAGS=-W -Wall -mavx2 LDFLAGS= EXEC=cnProc_gen SRC= $(wildcard *.c) @@ -8,12 +8,12 @@ OBJ= $(SRC:.c=.o) all: $(EXEC) cnProc_gen: $(OBJ) - $(CC) -o $@ $^ $(LDFLAGS) -O + $(CC) -o $@ $^ $(LDFLAGS) -O2 -pg main.o: cnProc_gen.h %.o: %.c - $(CC) -o $@ -c $< $(CFLAGS) -I ${OPENAIR_HOME}/openair1 -g -ggdb + $(CC) -o $@ -c $< $(CFLAGS) -I ${OPENAIR_HOME}/openair1 -g -pg .PHONY: clean mrproper diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.exe b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.exe new file mode 100644 index 0000000000000000000000000000000000000000..12f29c98445308a46dfbba5f440e46f22b8e55f4 GIT binary patch literal 361326 zcmeFa37B0~mFRy?4Vf!dndhW3&vQZ&AS8qYiz$RK4?>s+A%sz|5eq_q7=zfTDD8kE zf;I@WGCIW(hgK2WZf$KJ_EQ^&?q}ORyW1Xkzu#W>)V(#{TXcWl|NXz`uDbW`v&S{< zb@pC+oqdiwCfcHeq;Jcmt1;H z>#nP>y!h&KuV_90+?_kGytehc3tO+gZfEPIJ6ks&e`4zuS6*=8lBT91vr0{G+mdA$ z+}@Ji^A{gGJ9|Szwr_Bj{W_bQ4Xvx2k+o9j?7A%DKWiy{fGj7Pu1ObeLt`pLq_r{2 z24vYapKKJbb`nS=SU-hQq~p3G%lyadvYYJhKwb8-jknij-!r{y*j1NJ?wZ!e^%rUP z&OY*&TzlaS*OGt9RKA3*l@EASh8@|q9ZN1a_u6wwY?W!t_z2@1J{4hOw&TE(tE1qK zc_6cq%mw@|s3=5~avPVNcip9zUvTLKtIYzZjQ{K;zsg}_wrt~)UC~~m1vE+JPU)fC z4N*>9vb#&=PV1rEdDmQHk%wjG{hjkoH?)h#rO{sE2{cUjp3%8H@PY3&SD#Ov#IpnB zOFLz!B3N$esz_L7)(d<|zYDsSYuU7P`MOl_@oxa&OXPo(-%ENZw{m$Z*F2V=$7yUl zzX#c9Ic&^mZ&jjj_ShuSUm#!M+1f+7)oW74M3P^VZ;{KomfN^#=^B}zWsfKaNPjA~ zvuio}T^sOC8%VJh$_?W8>h9%i0GML2eU<42}t+42`@R5kYVedDt1qKlR^PrEG<_X`zejh@_g z%dZYFwA%JRGOL{ud-reiYVSKvY zky%7CBXf)lqqAqX(b;Www!i5c#&3xDzZ$5Fzs{y(ztieB1%6)F?096kRQlj_}ohaQ_ehcp5L>}t_jcYxuF#M`5=lvzvrgn z@+ES?RQ&d}>`TR(pSo>}STsL%ApiWnR5X7fQR{92{rH%Kz^9Bq9r2fq|EclrEzRt) zr6a9zY1IB}<5xs{to%4P;+u@09Ickf0-7ZlAKN2_UEpi8#wcp+4ybo00_1_iA&FYe zw+?^hl~;BrMDyLBmMnG6xBv1#UwH*ijpgdl8@{|}JinjddIG;0*ON-ulf6Fl%X_Al zuBVl*r}KLQxC>?5?gM#=fzOv2SW4}kiO6klOuXD)2o+4+(V2;*(UOF8_ko6egZ8~c z#M<`0(3T%)%U@{Q|75$@`LEk{zkFE|rUUy&m*`UB?I*TEyT2Mmsr^ka8UI1VhaFG+ zTg0E=b1iKsY`?s^#AmRgv(5WbPPaZk9ew`GvB1!4x9ja{M|AaV;}=A{$!2BT5Dp33ML3>95IPA*ee>=2gmApX4f%VH@V_PU zcuwReMDDC3@-rek>WREeBx!+P6lH!@l=+9E%&&_wzaf$u{B2R@cSV_hDa!o5DD&?` zQm6k}l*xcT^;JhCwbMW(l^HPiCnp-uv6YVQIGp?VX@OH$9B1af_6fgBSZ zl>~B7hh};Dwl7J>=BK-AmV=IkIj4_E(s!Qm*GBv<<0lZWkiPTE(wACRF!t?F0{^)m z*R|zeX@2^)Ej@Shtz&5JH{8CEqVsL~cM*TT@m~<{ByIKAzk_n0H1C_1>yWk*<@!=Z zV~(TNovB52ZN7VtRO=#b-|s4I4b8VJfk@K*vRP^SAdv$`K18HdvHLKQb|ViHdCAB} zi6l{Q(wGW=j7Tc{IFVHN&xoYLpCFP7KSgAREk8pf6@HFLD*P!Tsqklrq{0V?q{5#k za==<&B$5h$nMf-96(Xtd*NCLTe@-M7{w9%DL4AQpD*PgmRQNB5q{4qmBo+Q1kyQAv ziL~csy4RQF_)DGS*wo(T*l97jJ>4BI=q|@+cb4OWI?3^{O2zuQmk_n2U(3pM@k@60 zwDR3my`Fp&@^HiOBzdk=ZV)60mYT9*?^wRRFo zwRRCnwXPhuO8sn#2aq*^x-Nwsb!l4`XRNwsbzl4{*XBz1Z_kyPtW zBB|D!iKJR@A(Cp{MI_a_n@Fnl$3zxY4626Gpz1tZF}3$W)yHgQNB2Rsqw}EZJX>k0 z98@t|QNZ^Xvxm0D8>!y&pvsO!_GS)EgKClSxe-6j_$1;LgX;3~prXregDQH?50r+L zQrW|>dg~S%{<9&e!$rcEh}+k&`mVLwQj4Yg zhlK4ith&us2E=UT`8^r%k6+fdgQ3zu^oF~?yk`Kv4?n+WAU|2;3@zm}Mb2<@#-}XH3djW@{5lIg=u1a^$p;(^|@z5jiu|~jol|=kR&6`I+yTz&F02=I7S_X}qm2|~wmZ5~SU>ktecSxXx%J|9 zCDn1$P5qy81nj(#dl3S0tMNBR{A0$iB3>b>*Oeue{<=wO(QPq6oL=|Q^A9)C!z&nx z=y{jD)kn{d82@L|JBjRo>u;spSIql?bvi^=!b8NqM0UnzYP}=1SQ1&u+eKs_?|LT~ z*nInb(%PO;TyMDh;R7tLABSaa&nTs(gl8fF;VdO+2&BaLWkteQiiEaOi5EH&c0{A! zD<|BLdeQio+OSo-eYrB>VG@3ALI(*3lw|L*PO@j}tCGFby31Z$XW47*BzxmKX3d?@h>DZ8R9WvS&(v*`Mc72`iLpKe?HLWf{? zS#jTNj~_@zm!^^S@?gZb8h_TT}YIozhPt{aq>j{*=CV z&j-@gNBG`Rrsu$tsCHJ9ruHtXu-M$5Cdwyu7u7!1ui6$b1K0#gH#NER zFqrHF4ly~?xKlUccNll_S0TU^YLfnXRFjpKkEAAh@A=8~^pI4<{-&es?S}wK&wGr& zK)jP64@zqC1Ll3gavg$PB5_}8^53krGqqR}WXan_kh`hL!6h}hf6M)C`^RixV({$A zFsyCw^KECRrg773(JY z>`fv{bG*%4?(boO_pw80_S+J6f72$r_-@2+HvU!Ooy1^7S~uNi-lLZ55Q7qJ`x1lS zTI=G}Vo407YZozix~o1L*?jxkNxK^hxTfy2&*`v%zcTxqch*%{>|dGv@DEiw&w@Ux2#5jw5zsbA9vlPlslHGd_v^~$@x75em{n@|zjTYQ{Vq4q3G5>H!9U1$6 zoiduvvg+QC-xAQC?ti3d{R(JiEo zCsj64^tniFC3PODACJ^eMCvk9*RrkjXhMGX%ObVEQT{FeYTMo;PUGT_DM@q((TlH> zRYzPxwBhwBx{K%&=-#%yyVG=Mf8zsjHBaF8H?ID!eBSN0(96hg>~^?8b>`V$sNm*v z^c%9Wch|d{dEd1||XYD!P@ZE4O@lAOI?PQWt|4mUey`8v`q+Jq&ocMfH|CRkx9w~C6hA-zDT&gcBF}(%y81%%w9RfbzPy)&JqND+ zC9NMx>w7oPTJ-XR7J9yM1=kGLSN4(i%da(0+n6ms0C_Ja={N@0+YhwuZCXH?WA`?W z;^+Cs5q#Uh-o}5r8pZpW)YrctT8+Qty7?Ukm`w{9o!>?tNFG94N%O^50!dL1VmMz(s2$zV$SETAu^oQ{OX9_IKc4T*F2e1jY z=G*f2{PFyyyrphq-LAU(>zMD>FRS0dV6COhvKrd4w`zR_M18|kK;0M2MVVh`z2j9b z)7mTUm1VZ|LZ8lM+Iys7*D{ayK^h^r$y>+>pk`;RBln3>w@rco=@IEp-hI0|pGDlO`ue0~+h<>l@M^ zXhj{r7qA%1>l*5F^14te_l7t)Z>%54%+_LlcMW;{n4U9A1?TWvm(vBUQ83!5s4)^8 z^2SK$$gk+6zP_=Zx_yTYWN(3&$MQLw53|_zM@VzJ{5#@v^Q`?!8rjX~(Q1wL-BnMy z?Q9FSw~#ZJ4{n$3SMYg~_?M$}J6*P8%E&I|b7iDed~ayqm~8_7W7?0;PRLGeKePSZ z?ELl%DoXSjrT6CcvDu{d+3m}-mGqQn1KMXNSc-bOg0}HFf!s6sT+HWIK5ygm0O?Qj z`Ex!$;nVmk=;L_O?-yYLhQxz}>vhEC#e2!C2<;3SX_n36a}XbR*GE{F9ooJ=gG%j3 zWLw&g%-Y(If>!XlmoTY)a{IJwdi%U=LHojNar=@eN3Vn7(wOAo+EEpu>@#!}>?QK1 zDj}#Dlk!mT+*oLDrJ|7!JgX@=j~(GDT-t${n4trwsx)(UrmNvZtQOii{Rk$8N`(Hg(TtSOZr&2N@X@1guQ(#K~C-^L74$)=?8i?Z3okIEMF zeQ<*3qLjNJi}DK3#_T((yd!>5rhz5Oe>9cT^Kib{!OL z-$3dqp@aFuGQ}sxL*H%4vCdqVACXo|eKF7ZSj!RSwJGwymimq@@y-+0 zda4hi9jPfTtA}CWIg}QJxQQO6!hl4N7_-${P&05B?$%dbHlkY9lwVKpBk8?`?-uHe z0FDN9Lp`zP8d?}lY56~)ga4z@KEeNSHPmlrw9EfV)EW;3M)Tc2{>Nxhv&laxFE!;M z)0(QGkbL<+ggU{0Yu3j9A<#`(m;cf$_}>imYUTfg#Qzprm_)7M|3umxOG@<+{GSBX zI)}P!X6J-nuH^qbYR@V0e{MDoI?k_||4X>B2mfb5u~y=XfqYt`3Ag&HVR3c{{ViZx zvNu{p=d~KaY{)_-~>9BxpAixChYQJg7LOhW@?dX4D*??&RePwex>X z;{W#SFkGhAXD4Pyz>kx&rO4tT<>q>gotJHgZii&Y(SKcbQU(7H&T8lXMeu(YwJ(PM zSC{zzn(Vc`_FB%E0JWw-{W0)=GBu|lzjcWpweo)o(mI0aa9uV7t`+b8x*{=M*JG+LKZsxCg zcp>rsY98p>pM4?m|HkZN*_->t|L?*7hZ%o&^JggdA6I?DaAvk4UzWG#+p{C{UuA!v z#{aN9`0tFoT9}X>3FeN!OR}>{<8M>;hJMlivFs}3tqvJ<{JkT)5c=Iv3l@V|rjL)DNc|MOW>9`Jv@6Z~uQ zzphDt*hP7!AF-IvmcP@Ys8p)w5_t*I$St>7ZlkZ9a{EO)rRHk>Db`BXclPDApJF`~ zDKS@%yolRD)OG$Fv-YB<5JwvUdx1gux2PHL+gAVKch(=h1Ox$5u@-1x9#mch)pO-v zls6|q?&) z7b1i6VOMnaXE}4DhB@LH5SdfNoC(=t%&eu4@Y+{kSos7m zdz!-s%?9;2zYCeLM3fSmG7aS3KxPU9fVYs9q6bSAC9PFkaJ|uxDB!#;)(}#(o|%yJ zms--fj&iO}#M70DQjEbVbrL)a4w++%gUE9YFFsP)*^IEerZzn&Zhs+LgHqYr*8Hi{ z(wE$`x8SRo*rLDoEBwZtO>1E?cL;IUe5MYggtLE3i)XB$gk>mcb>s`F<(!?nMp9~& z6)gthI*fejFn}6j*xw+PhcR!LzK#4g(VBe^rR^c~I*^!ordX;W&G580h>@#zDJy2K z#2pn){EEjw{)VK~7)=9H+c`B{CnziOGvi7aT(?>G)dZzd`bC@4QRxVM68a`&Q;7}j zXKIv*Qsxx(i4siryC@eL#!?ZpwlV)KSCl34Dng9j&}K@#u$UG)NU2xbNH0Iit~t@a zWkWxOEzI1&Q~9%&vS~_asnB83cF@g!jhWWpAm5@tr66FD^Mlh>j11cpn|gTf$5I25 z4Eia6P;ty;eSp{xGa z2IaU?JGSr%Em>|iM%kd0XKH1>(1#q9Wg%okekkps|HUIh=>M>^7bQzsHT-Bd)7mo} zC`LeoG0>oekGimhYju-!ZlYXHN=u@kHltzG8%+<|IbHvU{jVSd0IN}YgvPXfD`hOho zhW>8>8e17ed+Ok3^2a31{I&jAa+~=Z0OrH^49EJRrEx4NEkOF}p2Q*8h_zIf}f=tUM+pSjX}^jH{9KF^V=O^X*8T zKrhXSpN?Ji|7iLdPpST#m{SOsBT~Gjp`+0;sFpOYc2RoFkGoKz|IJlWOpP45XKKuS zY$I9@-5aCbUTjr+W$0gfuxUK4(ddd5D9r^wWvARt-WA5RsCHBQE6S_iP^f!#4w))c9hmgxnX`&R>A)kZz z*lsf)$5)~M9rvU73yZBIwh2jhe2xGYsi3}5N@9GrP}VUn9_kA1jgH^{s{Wrq3psLL z=>PGwI}ur&2n54OFZBOJU{{xnWF)Ailxc0$V}Q%?EM*4+;TWV_`09u$`x&Lw4r57E z|4&GetN&Xlqt$;@>bs87WQ|u7CQzwzuV4gimi7NgdM*c_$9JDH12*ps2FGy`LjTA9 zXOT9h6lny)dSIRi#8c>FB!3y#2KB$R>2Iji|8t@2LTC{Bzm?ya*c4~d!vMYu{XZRk z&7;%|D5?IRPS4{h+nBgGk8h=EDiDna#+l^LrUfmV6R4-8&Ln*n)VIIT|8jQ_>HXLL zi?BI`{+~ySj^9H6&*iF8|IY#LR{C9zEKKElF}t|K(0HN$ClYHR*H#MsKcDNm(g60ru0hiT1a{;*e*#@*gp=0{$EJ_RoITD|0vpD36=6}O|}|X zhthZGe@m(VR{+;K_8BIDN9g})K(vmM%Yo@&NGIRz+oP>+`V{p`rmbsqtDr+TEshK=znKaYNg@i7wahXq54)$uSRt?P|rslR_K4% zTFy!vXvw_BQYp2WGZF8i=n6%|Kpfz+LtKR3KE^CzC#!-seze6k~HB5;ci@_5U17I$9@EdoyqJkh>QHQ@j18|7u##k@p$&J%ct1{eKYHsQ>2xZ-)FHL=W>x z8;K;(=cE2#OpP&&jR$-`zdqeFPecYz&DOGyG7PF7%dh(Xc-)r;@O>D3a{eFse=Rwo|Bpke zH&a&qzXDxy1YB&+j)o7F`hPVLtN-Qe@ky4JV5@K9+WEziaCZ>t{}ugz7Cf)i|7UU) z`u||4el(m`|DOhz3;n+%+lX`>1Ml3iRR5m_grWa8koH>gkIK#lvpL!Md?w*HG?~=b zk~ca#gU?w=?g?nq3)ndtpPiS+cmL==fgP7gw9v{P)(U#N7%I%iiBA20P166b>7@UU zhmJd;*mY3uRAAT)cLuWSHh>iM|F-OUaOtZ5&mrds^#Acl&w1>QU5xwM<)v6Jt)fh-}{}b zF-uJ)$6aObb}^q&%c(Q$KicXa^>ynT&)+zH3;jP6PPZa4^ZBU%Tj_m%(sg1mo3f$* zmm<&88Fv#Ir&B4>1fM2TqaF-K0#|sH#Qc9DDe8Y$ZSxp8QyIZ6ly{Eg-h1f(@#OS3 z#QeX||A!$%>i?zm_8M9}8u>UHcvc`0Q<0|4K);#v(Twt~lo`eD;Zh{%2=Z40(N;>T z|2F}@BYF*RZ-fGi$Qy-5n1EJ0f)=NcQ-`*hPLA4b46_OKu=BzGh1HC?JbN9OtN%A3 zzwV=LL&ih@pUue1kko^KqtO57BF#r5$%~QylgEYBPdv*H1t)%~VSD>x_Z|g<>pFz3M|F;7{g!B1nE5)7v zUkZgX{cK3Noese*pY$&29s? z1HgY7aK8~r9Kasz!|dySIlCge3#jkPb|YVtNe%t~d8GZU>`$_1lm7n{xV<|4|19J6 z0mj(N_ztN5pU*y!{T=doV@dyimXY-)sJT1cC7y>@JAw7@*=7G0^8cyq)8u{!-mCvV z0#54x$Jhma1c=|3=Kl|8f5jO1WcFvY{UlI+gI?7C-(j45BI*CPr1}3Fv$yw`{FLvm z|2Lo)bkKHAQr7<~Nn6AyT#l|dgq%jkv$^^VO+nTc0K+&&uexawT75n;(wx>;>VHeA zs}Ew_%bUUcu0y`2(b8J-LjRX%TD2l#n{DXIsX(wH%^wQ=e>z%l6?%Ugy`RqS3G`Oh z|Eu821kzrc^#4|%U60%!OO2K2olT6Fqmoup{~rwJMlvo6{l6VOdj_(1PSXEJcj*5% zG+%$i2w)qQwB;nUWLf{8j|5zl-3Kh8|L>s89{4+sk9zvf?0w)V;Cd&nvDzy1!P|KAA6q5m&JmiikC{r|`4ml??I0sLpS^Zg@qkMsX; zCjI~Q?8DjPjM<@#)8*N>`8=0Bie6Ix{}uRn*L@gi{)_DUNYIOn+JhNImHPj7X#IBl zB2HkmTusg&F~>5%dizjmoWgcdGs+#@Y9>&m{jL=l`Eh zseXL|i0@8*i;h=GQXW>6sxn@`Biwf6#D-!;Be^wVfm+ch@~ZO z$sgi7A=-~GHTbx6M?D4Ieh%ZY4i5LEfAnd(Jk17nCH=DnY3{6lu4P8O8hN_`{qvfn ze~#}{|J(=$)6k_i{5R>J_e1xK(DQSU&5_(!)IV4CqJQ3w-`kDI`D>Bs+t4TKpU)=! zb5GJgk8v+>R&y!$_4~4Y$oB(D|J=aHFYBL6fj#ukrHuZEUxog8BKueFG{bZ44`;&D z7rBdlk~>p<9{T4e*)PyGE3&!yP9$JeJ}z68tAFO@@5?^UU(7%MCo?AX&tZ9?f12~q zKYxavJdoYQ=&#QY%|rkEg8RiCNdNcK{BufvKeG1%eO{DxeZ;G}AZA%mUG!v< zpGVLD^O-??3;EGID@wgDdsp^U#r^9>G{O6m{5$}l(N=YcJC`W#Uq3=?g!~+l|15KK zKFfn=-R0+}!1z^GV{gxn&)4P3&%wF!^K;;OQ+_NX`5vfPhfmn0`PZPu{Cs+TMqZYm zwfUXd$lUu^mQRBpYx5!bnCvep*P1^}PG{(E&zFigf!ZTIk-N zrL+PRf8l3f`MUJ++xq?%Wg@r8De`Tld(h%%Np~@dxORwQFTS3<@L`A^ZNYvF?weZI zGNxFrYiLLbkz+Yaxf?Zrn0sPj;m`^fz6PmCN)L$iQ4p@ct^59%?YN5=7z8Hn;28=y zBW`~M4v`-z<{ARJh?l<${|r4+2GN2x->~v%>vY#Fys?C^*x7S8O?>Q4*xmEiy6nzY z_h38v;rP6QHsheG_FQdB!4>!U?MI7o?4pO4SztOW<=9hDqp}b8?EG_I*uU7{v<>|o z-2V!Twl)Ft;t3!v(w4P7_x6SZhgRRF%BE91_#RRa-1l3`%h}**P&T+BKf~`NC|i~w zIbb`TL$p-zKd2Ke1byv63Gu32O3DYFtPx%w@~V4q2UM4uRPc5x)h}`Zf|L&q%%0DTgPr*<=A^*bQzCzcakGwW1pBz+1 z{B?K2RAts*gHq;BYQST@Ii?h$d)wwHIew2x{kKr3kbhV8J~bny-RaP}8avy{zq^y} z;JPO*;qk58q>(5mvU&&vcpBgh?@`p^faYY3?b`Jc?ZO!=Qe3nBmRW5@1<&k2S6D}%+J zbI5;4lJ9oyIc{n@9`V zho|-;|Ff_Fl;wXRYa{n)m4A1KlqRjC%Kswf>4p5;hb5QL{>qdy6&SnocOFPrG|>x5xg1WpLjJY1cMU$3>HeS6sfJTRn~9I1tTGhx-$MIpBP{}Y zIq4S_-UilC!rX(+d*JX~cr$_?l+C%6b#6b2cHI|M{?!V~zmhu)YPgr@l~3K(Q*t)t zCsR`ScSp5ra0gqDi9xLS$MbPV?I8XJkUk2lPzzjZ`Uiyk zyKmk#G}Bg$;N{syU{U@LFUkKBRwae}FQJVUTrH)1S^ihR;jBcJp5=cjv=~dRQ^CzW zsAHg)JM&}dC1bsnvs!x%_Rm9D!)|AFF@RrXb35s4!1#nD|3{J5v;41O)q5tb6!V{j z>{o3o$^R+PImbFS70cFP(0B(>g#2%&Od~VtOdNKao^Z8nG0q|Cdr$`9B%@4rgULg#NqBznVw+cNISY=*A~~rTpu~ zHkQ;8NQv^V*V-_?mC#9WSot4K`})zSr@S{SU!8-sMl(ut0YT!Acm=h$V$*3r@&+Mgm-Qh3r(!t{`M;6cXVGI5Rx$Pe35+23G0smgUC)Z| z4a7qJ&rNBANh!UHQMRgu&rJ{ZXu!?@98150-T8-)HlC zE!0;2--@K2faPL1>B|2VJ@n93{_nwF|4fJczY)IQPtAw0s44%SMONN`+-#;yA^%U& z8qYZ?|ha&0gkd(FXcoy&vrtG>T|H~PBA^&+3h9yzX3`t#DV&F$YA4`bL#z9V z-HLTl{r?u=y911eAj3Cy1s~Y%1GeXr{2xg2{~_us|1Z+&dz1WsgkF|9J zy?z;+#ER^5CHa4j`cK2Bo4U3Cci67pjpdj5PQDTQPRReg{3`$2am(^QBroLuAF<-z z4UdN8%KrzG-S;OwNN1L<$v*?M>i>}cf5Qs)lWc0f6X_U~f0SO2&Howur}BSB{;$aY zG5NJvk?Qi_f<(?J+=Y1f_&qeGP6!P;fIB_Qucn$W( z55wsdSiQ!8)t}Mh(-~sB?ItgFg3Ssoa(Q3-tI9)~=)2L6AQ8cF^bh(C1f- zZ^zf4U_)Mtd`X}C;O;%yOX!h5#lG1!tjn|K(`zM<$lq%`A*j&7oS)`$9Gr@%5kfB z)r}OL+A3eT2C{TrN-D03)w*q&V|wISEK*X1Dqn>KM>~R{flpzxN(rO~q<*`S30R8M zDAW75>nowr`eWO|Yux(ggpJJWuwGfpn6vC!f-6FU^J5|O4iVIKCF=S!O4z0?+NYSh zj;tlP!VJn=TWf{Zlg5-T9k{0U>+wo(lPjdq? z)7#zof8brceSPO$vA8}63!7^aElOc?lP0cew9W{D&w^<0DX^>FLm`VwqFB2gGhWcZ z>qv=}kfn;eYOO05VONN@m2ss|sH3Nlm#};kHZVC>@T2b@Y)#vsAM3crQ#Q0Y7=kwb z2KD5$xJj{Ef_y9FU%QpoCFNfUDdgXkquh5*uf|FVuOB>U`q*DIp0jD;TnXDyTOU~&e|E_$h zhtO_%I3aWh5YOPKZce)RZNNZTps1$ zr*8E5FZ59Yq1P|ve+rmu^^_8o@~>UaXI{qe>l1t0HarK()2I3)|5NEhFaOm*r~EGi zUeBT$#d||ws zPLls?=(`PUMuOosdZ|tRCj*IhRpnnf@ouHhv-hu@m|426R?At+{}#Blg_bj{KZl?ZmLfHS z;qalvkAd6k`7O);vDkz3np#tDLEELNB8BlaJEB_7ja|yH`4~Iv=0pb)?p!{2MBDAQK{|i_x&V@FAl;r<%`aFZRJMSk?@_#;kZmgwwpnHrq z)aw@`pYvH=Ka%ACE-WU^tWeh=LGS4z|7U{hRy>1h32(!`r~ZGmB>!LIY8Nej9Y4_% z@K9^vb1Pmc?}ww8P%h;ETkyJe`F{?(%3L777Yo?kSiZgueQ%=8A0q!h!!~vfy?>aM zukwFazvX`ht$0^lgv>919<50G+z$C~k8Sh6!t>bDTKjjMfKaEj;44y!@_8|YaCi%Ye+m76 z7k-Y-coqF!N&fXr;Oii zoH4vGpOJqH-hQN${#1TGfbIX|aO7BQj;pXA)}}vy2xRwTtCBwNNaJeU$umSKK}@PPRyUf{#KVAnvcw-&x_e{`IY#+pN`+(jQmacitNl> z`ka?LzMAq{+Sg(cmYIlIr${O4dj}1Bfi{Df|L1y^BV9|#*& zoI?;LY{|J`*sd(4jUy~Zu5erp`!UDeR7-2mkNKlJ^*+I0oIv0##1)w{IfIbJ^C`{& z#4KPfehd6<-L_1(_lOtk!NA`YWUTYT%0@BDIkzorTta8h!W$v{6kPkoNl69%`Z*b_ zQQ)s1N>}`SV%>8x#NSKPm9nvtb!21^$lO&iF4z z6RqK%5%^EdS}C!Z&r&|Z5ncg7cfB5l1FhDPGXAcPeFD$j)Ev6j6Z4!AL*Vava|lob z{*y?Zn{wT4U&WO>tKvVC)}86=VKF_GSPX1F6X&_Feu zO8B>NU*8A*JJ|y}z6<`hGB*&H%u`l4>Jf2yg_cI6+6aKfeAC#jr-^GmTK|W>t7XghY!}tWS_#XmwR(9aOjFjO2kx+4YdS-PA zbMD~(iS&6Jcdiw{|2|+B|JQ;4>zPLwKGX&Or@;SKRxt18E^lbe*RWeP4tPiAli0QS zPo5(X|GP`_{{!UzR_^Nm#va|K{G5Dl{$cJ-+bMe>)z_=wa(dl_|G>ow{;g2rCNM7e zC;S(2JqXGP|EIw1E_VK|N%e()RxbQA^26{|{wh0EL-U0^f#56Hd^+Mdc6H`M;S+hP z>M7`B`~Tk2{uda1mF@pyYJY29v|rpO)SyM&hRat8j9$M&BbRG>od8QU%CX)Wh`WmV zOna01#ZTyXb#b*2_QSHRTJ`W_Zqy-o3TqZ-1872Q2h>>~83*Tir$-ch%sU^pE?i z^sH@%!J38NV(>3Gsb(tAGAPtb2uj8MEbi6v-@BQ2iQ+EZOJ$PXeURQl>z!T8fb$V) z5nhkI*EJ{juYE1%G}hL;H27cLMqA1M@F4U4>D^tAwEpnF86Bx_nro!se^Y4=&=&@J zv^l>Rhdv7atKXe-$p7j#Bq^p0I(KrfDCQU8p6C^L3rQko%7w9Rk z;JRFxt&S`@Go`dAv#NCJy(9n~YLdW(6#Go|W(ORze@kHwCFXc?g z@n78r zllWf6r$79UbMWM(^Q+<1^+bXg9evTyd#_%)YA(-M8O^Vjefd`#|2_YpfjYDJ3;=4+ zb(xgv&!mNF!Ba@IhUCy~40q3gaBpSe|7u#*I^TEb%>TofTP&u9LlggJF=MF~reYB| zib9)8{6C3a56kqll>g@R9SZ&*lK8(G{-0ao|Dkv^ZRxu*x%%V<|4(6_bs@8#5zIo* zg8yeh&y%ax_jD+|H78Try-L?I@_!0{YNBevx&8>GK8I?}@WCgb3;s`MEl@2iryu#h zI`MxA^Q_lEze&uc*D$ACUadMa-GcuY($1w=I!=fGM*;a2w0c?9`rD8+*IN^KQtS-; zx`O|=K^4y@sLucEu{9or?czTC{?5l5@(6T)Cv(`#;r}hk@2YPQ3jRNUhmAgI%b0h@ z`2P_6f3)w)4YL`2RPF|KH*{;o$!_s@7kFmKmGorHd2)S9S2;8FY32pTd0e z@Dl$w!2h#Y-K2laSMC3n#Q&3cI@0lfGyK1o+3)MHvffb>|KA7yUr)bR;gMA4 z|FhT!uVClmudDXIjkU_%ScE=O!T%>%G2EN@|Lv;v=j6fvqx0E$CI2Vqc&6niS5>s_tYQnMGC%ycVV?KHs8tn+g?V09M0+~;QxVyjsdWOXYm$BDU&0%1;4J zQ9^rA_#kPo(OT3wh>_3H#d&c(-+>EDm{@deUt3jSAL|MK$c-m`+#BeQzw>72-?5hH z9e;frhIa;@E9YZ@zwhknj=xW4iNAZ#&b7MZuRW}ZJAk{zJ>f5O&MymVUuO`)_rlqy zHb_@hor7}}=gB^=CH`G8&=21876X4zee4{(Te#wJwk`f~T`n^(&0pky;NMk)ioagL zi_%(uW)Ju~k6DNo760kX1G|PY{@NqE&amTjU1wk7KdKk}r-A=eG;d?KJM?t!2MyeJ zed?$VD5rPn{vfXP-=4^wSNy%M3@4$r$8r~22LA4aZm!HEzPW_|4(^s0VsGlo|MlF% z$DmWhAAi|y__qL^r~k=+*GFN6D|h0FJkI3jX07~<>Xz?0P%D^Y_|%B_A6>4RV$<2p zYXF9`XyIV+4=Y%?koaoPIWOUVN;mu;N%-Gc!vD?P@P7pSce8I&;D2qo=@fgCzV~PU z11rzlxVOK%8~)2m_|Jh0i{Vpu{7+=o82E4Fj?xvsJGe*O3jTLu$-9F2;eB2D5B$H6 zKX%~%)h_ws|L-06|EwGSXXWyLEqh$@|6shlJBM8f{u8ly&7%LSm~(Xw*Rb#MUWnQ%ZQnoAa-hP+vN|$Qd_$%%m z>S;g4brFm7a_LBqvPE7|r`%#uJ93J)yZ%NimMw>J8^*NW#IGgd4p{C@U1+}F<q+k^{#l|Z9ru|iQ--P>D(~_um~0{H1|CtXfYO$Wp!F?04{ghK;uHPG{n2}7v|ol$T%5amrzxnU z%}eWJ1YvNG!cTbr1zwi%{;P+hDV8WKmBQRPXv5MPWw4(2v|@H)s#Y)YGA-sC(ymyy z7v8tl7Sbp!gx($0q_*l+F>A0zYljq+?|uPUcla!;AEhnC6UVk&w5fGY-0Vjx`RCrB zeMr0T>a>Ql2I&x-E-ZgqL&ZxgmG?R+ro|{IEi`_D0z}f4zm>tAIjO9#t-Nq&YMUiV||f6ibItCBK!n3p;QGMw@=XibVKmGR|!=e8iMe%N3^+cuq^Lg5`{`1^x&+iV;{!0Bf zj2@-DSQdJy;B0sLIXVmdCp{dg&D2w0cy>Xd|6;UChj>C+PU(T`^XsAiJcT=+c~@E- z!P3w)cPA`4hAU46_gR$K*LEj7IMN$`wM=)`fBJ8S{_{<~q5t9;0iPN+=usW|&uifg ze40x3AfNb`Yi0cxt0>`9clk7cIJnl4a>EmpM0*Hv*7+c6PK0xwQ!drY`p+{TCW5uz z$&<+SjUk?*&`hct$G5YN=Q{M?Skk?(>K$)R_&VsJ;i<7@{pTs!N|mQaWXWdT8~qCX z7al9>E;WdwB0he{om`2I5gB?WbdR#_4omTIM90WgD=Cl8K%}PQ!f|YS(YB*IG++0v0K)Ea!A=U&(E-2I}h z7_;uP*+yuap5QBX5nL;l^v>p`t zPswuUL(iY#lo^GDI=2%^q+p{?#Hd*H)DTcCf}a+qh6E(^Gv36rT&|SUsR$0=A`_dzM5GFJI7m! zMWWDui<3vyeDL(m--F1(-y>_qCNco)h5kCO{nwIG=)YN%vK958TnPO)pH^oB-E?rC zhm_2shNr-I?)74>2GW)gb9!N~^z#`|X_-O_Q?&Hu6IEJE{naAp zJwY9y+>WLNXCR(C#R;b1DjtPZ(WeRA^;GM4_Ki~PI1c^icxa&oz2@Rh<`XNP%%xwE z2S_-hYI~S4n8O|zF8xKJJy*)+;_$JmWt4S+TIL40i?Y9 z=8e(mKIlHFW!$S)|LHI1{@HY{#?zB94@e`%GibDeX|MBXE<<35HtN!!kWHsFaBzirVRqDTk*|(j7)vgZs z^N{(}ly}~yY|Em??>Kk_)dA{Re zHgSFE%ldC6rPP00v1o<c7>rp#D3NwAt)1&I1zl z-|?g!1Lb^Q&wo|_9ZOp=52&X9PNbas(S`mymFu$pI~i-K!ISp0Y$NbF0?Ybu6R`Fc zJhfyCGn9l!pP-+Xd*0J>M zDL?AJld&%^Wj9^@rw`_-lxoEusQ$Z#`a9r7=)axVqI;7+@7g}S7W&WUX7$z`4Q!M7 zj0R?(Rr0+w+LJx;$x#z;(ox2Sr*itv#(XpMpB|{{KW7W-Kdtfcey(~->P68^y-B2d z=ZX1)6zo1eMo~_k;O`LR!x@Elqv?D+4@?cC{_}Y`^`CEZ5=KXz&$U(RKkvX|CkE<2 z-{yP($v=KTS4b+>-Q~w=JZ*t=tO1~C)QvY2-jl+Rt3@JwR_R{vd#6qPp-_D&w|9PT|p*;V)mn%_HjcVV8;O^8QBwIZ>ma@()Jd18I z8ZY$U^pgIY4#oBPSq(R5QnCrX?7LlMwWL;u}QPsTeuJ@nN7UVe|x&c4y7@nBA z{#(Ks=r=--zV+W57{8ZMZVOuYN;L3!&}AJ`JdI}%9KRPJUDu`Ydp6SLIiQyynb+`% z@w*fKeGU?}fgRPkU^$rk$#CF50vS9PnREVfF1p?EdmXYl6D)jY{7Pi;kB}Xv6#nw~ZR81z zFJ-?5s+hm*L5Dv^xrXd(jDZg_vcHl|$p0#h-=+D7ILGTUo&a_H&gE(W=gLpYWBe}8 zWBfjo#%}}Ca2(ovasIPxL*5E}qk*6|_Gc@&fo_;_qh@e}9+wdl#eX3()q*cyNtl%>NiHKf@UR--*Ak@XX0?v;PIG z{|0ZW@pol@EagY%>gV5=^m7}?T$Q(SGTbPhsJWYw>^XGD0F8+WZ2J+VNN7ox^DtmlI;*zT&G1a?hQo z{_x*@h|%%wHNp|2f(Ed@SZJe2#Me&Fu-^oReR0OVU6 zEBW8oeqC3*wClPPp$#(luhpWf*JIaO ze;Biy;Qt(2nZ!C~cCFQ!scH}M#CLaC=DJDPrI%)Xjxgnj?fh5e4h2w!ph;$ zSIPfXjG`5c|D*fC|MQsDZA|<>j`4p6GyF-cdAoY8_KwYR=24TF7YF~(hX2~lYUlqk zST{C8^Ai|1iA|6gOR`!M{!hLzIItg$}_H$TmHtzkKH zeEEM*8vkdr!duT%a+i;XJ zW|^X*y_KX!e>hw#9zw1!Zaf#Jhmrlq`rDlFo|nd^iL-c!cZ?5lagDDJZ|&>* zINv}@h_e!{o$E;vlF%=DQ%OV9ETN6S)@p}O zzbdJs6zT00V^p65@zit5(dmwVz$3(3RK!V-MkQA1vq!mW5Ld0LdV~h9S{))5o>#Sx z58t2W&Wvs9%jsIU(0@X#M?mNr%jw@GTyiM<#ngW>GNn=IKkX38r*wlNrJ z!WZ6m6nf^h=kl0Z`}%4GEr{g=dX9JDIVzPZ-zn!uKX;{3&mApDQrveL#+*r?AIHiF zN?4}}2*zRG3e6WM$7{dzP2m&x_K5@IwFdQ{Z!`$~=esiXUef=n(0^lrC7y-QM%aSi zjy6lZ{ab)m+0ffM^q;)+9caGuNsXyZb6~pmJx`PP6Ekf+wFdnT3;pN0dA{{bYn{&# zPvBbLZaoY2$5!5aU!zZ1_{K?3H1vE%-?5-IM_Z~-`q>wH?!o7;Dm`bJ3gpQq;gUP<4iFb=9IW72LAHIyN}`K>vcTJq56 zTzns811)*N<$Qh%{Wk?D^_Nrs&7p-_gAmQ7hXu%#o`jx~ITlKcp`R(hs;9a7Zz8Fl zmhO8gn}Bi-c&YzpLZf+<7)VL=pYH(}O4<_SQBAj$G2w`Er0KJ~B&F7_{}y7QF7)3# zpmTl^`fon6;%5Rpn~6O7Hn#@)8_iYdKfU$jbXot&g|W04@3r)_d3`6B0QWdrQUA@P zMt}5QD>atTubxYC$g?V!VaaQT5;K8rHhp>OyzlW`&bSHvr$1jSWz~Pv@lWvduO`Yb z=5HR?2a%^gX`%lPBCQEuph@(#0Eqje|9q}MiI|IJ&bL>p{|-qoPvCk16dOtFqk&H8 z_Z-)y^fd$C75Z;6_~;4kIMuIu80DtIQT5+Sc+!HsbqVdR;d?Rs@ri<3!%DchfmX`; zZwY;`0OnD^tNvR`Q=$L#K=Zvd^MQIHeS3Fg*J`foFstN%Rf=ul{;pZEYcJ{}L76?_-^&-e7k{BJ_?JM&ys z%dUi4hXBEmV4?n73zQ4-!O_bu^xu*6@ZYch)&j+J_9jN+gT5JTjse~!&{AFJ8#N34 zcO2BxH-7-T5bD3JTu%kICSo!FJDAdIYGp5;L#v_5a`q(De|l(7$Tq_5(0`uOrO)Xi zC|u~jrAXUWQq+G(QFA`!Hvz=}Y7f98=qO}E{kM)b=izs>p1*^j;?a1$g#OzOR<(vU zTAEACXD}9yrKKT2d?YPxfhxxV>q+dd41{Y(llodPSO57Y)KlnR{ilEaY0zU0@)i1T zEx*27@lZ+}fkk{H_!au^XgtJBJ+xNvkc|uB*^xjp08gwT&?fZXAwaV_eU4+d=TtPq zQ9#+iZcgaGP4u&!Ubc|u`vbO6+B%{CJbhyot*QS`1J*;3htt9L7)o#9dqd6eorX?O z|83@X0J|{izf0IpcnusmGwDA(bfA;^?^60I>%Y_3`BDF!4rCkHz1czw7xFg`pRS#> za|$h-0CzU)73Bq;BZHjmS^vzpX$J`tMv|K8a@$ zn&4Ae|6Pi&nEFp{9tsw1jQumfMg4bW(tp>of2IDrjNC1h*;yNKlq&S!Sx|l=5;zVF z&tw0rtpBd0R1P)Hrmv-pgwgb|02qftEA^kFU=Hbv;M;}J{UY?=$tC@_9Y{j|y^fNF z{<{G>)EYwn?L&g~$v+c5PX)_Xd{EVY`dz;sI)wgvL$-sw$@s_}!+z8P!oQn=XBU#KA7ki0{pIgqWcr5D%ai`w3!UBtEb71a@Hr8G!_a?kqs@7EJ+9}y z26r)5K8QE>Ex>mvF-OkUV|MWt>93SSJ&?9f4rw^oec|1zqL;O8TN$cqAx*Q363oTvUq5mELkI&K4 z$0_|N-w)L~Jn%)lhY_oXb?85_{$4lzcSF*DdM>sgKckWOgOI$xNc!)qc%MFo{(G{d z|K64K-+Q3&e#Xb`$mZw3x2*r}>!<#E9E!|A_U3~7Ka}*}$AS47w8Wn=N*`hzu7(~T zfok7pH~1v{SVRBa4W;Xl#~*j-zrVtN_Q&YI_i|2qq5p0LC-vWcuu%VfnleADnSLKf zcAfwEd_r0O{RU~e2T6Gg$l_;YyWX^iE%%zEZ}%bW+w0f?G+um& z)))eMTXPS?Ae8QI*k^hFI3N%<_Y`^yvDa%0mMhao>uT(A$L_DYd4Z>W6o1C;Uo3hK z+P%zozbf|Dgxvir+b|{Iwslj*%3ZjiTI^ZcLT{mmfblpS8`kW%pb><)*+?xQ%OT)0W+z9YIUGZ{UuWaEXtY zg!R__18Er;X}NO#+dKS0Q~MVlF^G3Yhg8^-bE)vl4p`k?)ZXs?iFA*BS|UA$24+LW zuC@>wq=jd2X_@!ek825GcX!mCIX~`d1f_bP&q;Z`6Kqvj#YbLfeOIEC7vD@Bw9-nf z?b!V``Jp_BkM(;FA)oGIhJ1#vwmVers1@?*+Z&_JXx&p6q>Vc&w$MBL@-gp~myFLrWN z+WG8uT+5B#g7RX%`xfpD`utCvSK&@T?48NmkbkKYCuO)>Dz+h0wfl=}(bN{@Y}zv~ zJR!rKH058Lio2dlRaySs!PBR`=itfxN`34(d!DWG?^~_h193Of6J_0tlOpbwC@;R< z!kr@b9PF|8@mt9MDBv7UTkanF24hc%8O;1UPS)`}8~0LzW`+FwE{qm(JRz&M;Eq?E zyXB6Zdw_-f+lTeF=XyHN2%1p--TkU(RT}c|Zb~)z7b@*!?pu1g&XBZD^$cTE^!E3R zD&^njV11XDXM8AG)#cwa0w&YaSlZGy;(L{q|4F2b0_>)-*;NLhpjZZ8>#${ zO?``7&mrXBeNo?W4^2)z&9GgsgdaV0|c=XAfq>v}^_&%^!VDMR0cN~>}pDM0Bg#5Px*<4!D+BKB9y=Q`q zV6`xXwv~S+b|O@C_q1>M_oM^g-7$k2vsh8f!G%fwJr!gQ>+hkgl6@LdxeEM4j26N$yJx-*@-a;Y&E8)Xo;H~_x1Llx_&!zDFyvqL^cs>XyTH%4G zM0-N?Jg$B7TVL|;6YdSHJ3aIINZO0{3HyFl&&8QcJIenedOw(}!}+wrgYnr$FjD@t zCm-1x_&uZ-@_#TExsd;r*bSBcbtU;jj7`9Byd;aFNK z-QYCm*oFUe%E1FIubZN1xSnTG^{G_bzF#@Z6>zcRp1u# ze?pS~?O@VIj^}Fi7V3cd{3QQA-EjsMjza#=>5%_6xVW<<|7T;VISMP?T52g5=O+2z z*jw|+K*;}gB< z0?#$nycxQ@29B-6J{9tR6Y{z%$^Z6}{9m2q|Ml34)&j*P*vK|w7doj|_WFUVl z5Z-_-=hPnM|3WN8hjDJV@_zxXF2_=={GXfTe-Aj-9?k{Zfk6G{B>xw{zm-@<8?foE z!$Ncg<9j6%Q|SMu6F1|q zcfAR_(t}tP-$wo3LZ$q_4|%=;%ho0AL|MA|)gY|I^*e*kkKZnGT>59|VKccac}o3*JZt~geaipWJLLcCyt`5P{|4~= z3i*E<(s~ne`|BkCFLucP{qW$Qll=dPUVifj`TxIK{W z9%I#mE6eD=un%d)GPRc4Mf+hV3LpN!!Bwv`S#fZug!^`Lz~PsdovhXqdi zO|0#!*Vn=#{sD(pF;_2zC8&D+@XL-BnDZ}J+^!~Foz+f3`wyRAZ7sGIK7ZBw4?Cef z+Mk}TLZq#&_cd*0t6Fh{+I5Uj*l*arT=`ZHVg1rVqd$7kKhE3Mr?`61uA#j_|H-gl zxhiyxXiD{Ke_&q@?Zbq>LK{AZ?|wex78}5mBV#h ztwC7jzi)w-|Jp-h?OLq`Elc4~9B&5F-&6kU(_2gb!GGWPspUbR)`I`etgDCM|F{zW z^`6y6;knAS@n3rRmYYebrk0y{6R7^OwejDRw}bz_NmL(M*AkORt%ZLBDH;6Ne^&nc z6u=ipbwpXnR>VRG=1;0s&f5^1^-xt^C^e8d*$n7Ci#Fy0cYpc6 zl)7sY|EJN?%CyRvz{;w2{?AX+wwzgK@ZaCHz*IfVP5hsq>;t~byWsy^_`j-pb>@uv zU2cZz8%q2?ocY)+=4nT;R;V?sg#L?JVT_`s^~vh7k=WK6svi%Rma)FsRKfovNOKKY zi*-cqeH`8k^Q6lA3h3dsLcfx997*2aI&!_p7;0%*Ufg8vu8|7&aLUvIB- z+2=o%U3xvQX0jskT({RS@2{QzyP3%^WS3x|MLGL`2P%Ri|XM{M*jmH{Qoj_Zey+Ux|;d_ET^np%zDi6@3{e&vMTx! zUO}JZ-HlIH?;e=j&ix2XsjoSw74=oRw|wI%`H|c&X>E_x1M+M;^Q1MS~I6;&H0<{yJqm7 zTm)16b6)H|uB}8LQNrFM*ZFg-Io!!Bf-`A%V4c^;+`d>Z6(#(&RsF{OI1?_{cTOJb zsd(--cGSxG&bqzdIu8>*pGd5P-!@~8Q1dYjJaJ(-Z#g&$&0&Gyd*ex_98L#QnL-_5*+S zk9_85ICB@D9V+*)zpwA1_nawV)uXGjzE2xYq=fZ+%Su=LCs3on-?`;D@bT%Pq6hcY z>{w?DQeDQ_lAU zdEX#XiGOk0y{-Fp!fQjU+NAp*aco8Vf&U@g-0v%r5RcIYdyo0jtf|FdcFd_KzmJK_H)*q$r-ANc=y3I9)HPy9wj|Nmd(Ur@^5h!-g&)D()E zTA8Aa(4w`q6L%GDQel@WzP;Df62d-X$>=@oYR0?X$9itf)qOy%mNusT^*$AMyq;^7 zQ^T&|-nbZq7nZfX5`u!NX_E@C413qI6Zg{2rMq7VuU4giS7`Kahl>wg zL1?`h$;d@iE+^ z^nP)z=#%7H$h6e?T`f3g(M!udz0=7-?MyxqUk_~6g7Y1p{av*Qf`DK_^pT-!-*j?`*|33!*KL)06LT2Ru>AaU^ z1a`VhX{YZni8C>0v2VW&kAdL-AMxgg>)C^M{6E)sWpX?7|4Qn8y~O{|@|@BCVedWQ zEUT(S?|UkDbyatDuFlo5I_IY8CUnyQy2;(-AT&7$O-4|}0!b<$h=L$V5CJ8c5EMln z11h4JaCDr}XBu^8bo4pj%p1S?{{Ox1se3ElTa530@AsS8Rr{WE_Ss?Wwbou|@3q(7 z`~HgQSChhZa~A={-C*J({8tkF?}itzCH>&^yP5SzPf*)uy6Jx(?f=V({ts6{|A%RD zAEf>N8GV@a|0#O8yP^NzQL}%ChLzlZ8Tx-TD|B67MvJe5nR52vAfm2w`@z<|qxa4CN4!~FA0f>rx%c`YSDWkaxIYemR#{mD_jDOA(@0^$jM;PN_k7pu=_^Ei zALZW7^=n+ej=zulZ{Xk0{mb|Vxc?UZ1KhvD^*i{7xqpP~hq%6qKMH>-aG`YVQZPJ& z{~7nME57r3b@AD{SP$b*BMEI@06jmvK`q zVKp@lUNfHJuBMjZf$v6-88^Ot;-tw_rcRsQF>}_O&Ur=PK1<^FP@ga0Z|DAtT)%|B z6aON0 zu5EbJm{vMSSIa5VnOIf2EFlJbP=Chq)><6Z*3@SBVJ)pAMz)Qzi{8U^JwsXVq|E2> zFL3{Pu5ZU%hj(!mw%Z7Q8rVL9r@p>R;cK~H&pU9Fa3G#;=bbz*-o)8uTy5*G;NQSK zak_SJKSY=KHthS-4dGJ}>u5SXv=kVVn>GNDy;r|K`kE@dEdbGOx!NC<6 zpsB5`tE&g5vdCQ@1LjZT-$uP}!Na8qhu|*Z4cv&U9^qTdGVm6*#=**2p8;XlOT7Os zd3=iN7oskyPPcMz-TJ%QT`zYvHFb3j4ULVpee*AT0@$7dR_S^Z_c_grG!^bb6F#T$ z#l*R!7#}|9&)HrfVQs3IN|V9d%ar?VJaj9(P^`~A{akZ;T3_E6pZjJ_;i>d`Tth=m zrShL8{*8F*n0OsNPHm(3T*k{#h(=e}t3=~}hA??exb*U1eqW+ROZdhr@6kB>#3x_hWqQdKY{yy!=FtV|AGG#_m6RXg6or9*K^&#bt6}Ca|6DUv^Q~G zSxj%(V(xv|4`m5Y%3t{QB@SKVRQ?vO2NpeH)jD`kIYP#%=_a8<6Xvr~gW^ahch<&# zQbroLA4eU#zD)RwT)&Fr~LBgygXqt|9;Y!!zVn}CzU~dd0u&ay3?1z zBYX))%cs2LTL~M9AIv3sK$jZ+Y)eVZOB24~b+r(q4p&oW%dM$Ntrw}qe{CKA17v(2 z<)6>H3%Opz^(_1X?&armxHcD`w{frMxkp$P@B53N$|&a7eP8z69X3FD8X{T}`YJU_wpQm*tT?PnEU;Htd+0$1BOKJ_{Omg~pxKOu~~Fr_ba{gmtf zF-M(s#Y^`!4>7#1X}F!zF=N|{-SXLUQkwFgn}FNzz=yfs!SznA*4w(>jkjJO+N{? zmpUbQw{rg|_sVAKp3^VYpLeJe<2x^1ufku$^R-;Bjk2{kQSoq%S(b*bQr<*Rc^{JW9sax%27m0xWe zyzAlo!sAoe&-nc%z8>5);IHQ1G;8sD;D&EvuD9|&9LUGTZ-f+o zyW1Gwk2Ln4%yl+?8h!?O2rFfkUsM0>62ea4T{xiSyO%$eUzO+J7L{M*L!_=L_*S0B zm9DAG{CQZ!?s!*aws zF3NTUN{_!T*PFz<-oJcXPvM(=6tZc3;Q+XhjWzk*jz0?C+=AauTXIvyqq>fx#vA)^ zd&<(TZ5m#%?1y>-M6slmUCX;P$Ddpn*?pbUmHtu~2fpz{48!O_k4&7^15Ce5bU|cM zJI6JtN1Vs#B$bo-RsD5k{^d!FSMx;_HVvbbmy}4UM^{sPdqCHLj78S+x3z08sKp^| zT^qW#feBkia(Ra7x)@14xoZkEnZe(J^gE+#Vb}CT&0>6Tm3QcwoP~BAv%x5$+Z&cB zT8!^-A+?^Y_cth`(5#`gsji`E!l?G<<$LVCVN*(!|D*^|!#_BK`S_ZKnz|9qjV(2e z4I_rt*0wdaHaFId8QnU5#PE?VBbytCjUF~?^oWt;Cbmy(A2(|J=$0{~CyrmVcrlwW^7%_U>#Hk%K`*fM$>z0O_@;6`ayq-3AiSv6o}6#$ip3P0hpT_YWU7yrqS& z|A^Mskt0WpXlonUHhR>kQDeqX+PE=e$BpNILOcHxCt6IZPIFCtLtSfY2Wr^)ODhx} zDI|@WUjF=a)HXL{bxky+`o@-eewynYe>64^Z>=9z-_qPVyb)F%K4SFviFPb!%$&Pm z;iAP$mMvegvUh0-9;#Q5~ z_%nsDm-8EDpXz%N-!VttM8_1PX7!_+7$j$kJ)OBEahIOr+1vbmF}N^oO5^Zhbxkcz zjSzKsb7OOJYh%;!7Kk1(T82{@3Pa6_;}=Tu5>XoO>lvr_;~Y5>uc^6V>@dJ6G&TAQ zG5Jky{DkKE`Voz-;H_;~3qz>3q?2r-kkUC5T~<4;{};umbGfF@3b_$6@+eEeu(2kqkAUv?WyRFe=9AjGEUeG1-*cp8 z(qqx*NPQN^0`?*Q#Irgt^=5CyKi+RO`eZqjfb`95BSk0P@1^~Pk8}T}$fb)Sla7OL zeCkg|aQ=(DFKqM+$TxC(`U;*@I3$1;(wdpsn}B({|J5~{)bZhKe5ATNE_pv&i#!Ao5IgjJK?n!5tURJItO4awVKrSe^GW4*PpwRLHw ztG%%MP4}ire|fnBocr$yaqQ!#wXCZ_qRsY~raVl^pq%JkmUfcWIM=^>u97QbTxFwG zqI;*;ayPPy48|7e?>=Thf2~u4{u8Q5?>QfJ)YkplJP*g+&W1++Xf5Ji`iXh5DGlk? zRCGD#OMfk8gZ`$>?b8R(q8Yr&>(XC*1^q{Yy=v+2`BUOQ0|)NRBP~72Xgnd6UC`eX z=zF@F!mOSF13XE8&()b*q`%ggby$~HOaCQ&*lquwbW>C4;C?ZXPfs{mK0uk}!HcmE zt)pY$er4^2h1lfn1_tJntEb>pc4AAZA>KVP$GsG#q;jNs`pfI4(oWpG?B%kuyR*D{nsS=?_kC3 zo>2POI+UPk|Qh3e_=-c#qJW;+A=Us$C7eyZ3i zI?wg+d@N7#nnKE{@UJ@;x>~O~`cH*hN6{UwDa?dwIsMzoqZ<0Jz&5di?s-oCeONcY zA<=(Hp|7%`Z*_LkrQbx^TY>yAsCgW4?@ie|nS`j0{#!}glm1&Nrds+R$Lg>yaKD4e zgPi`yL;vf+N%i!9kiOcDl$q22dfMUxPLEV{52g11W2P&9MKAFT)?iEj_tXA|N`F@- z=Ja2e=-*kfbn$dh;gBNzcO?3|KcD+dR!jf4C;FcTwMNq0mHxLBE+VHZokpqXzM1HM zA*`TpUf9}c__}|EmcecN3@&6>Y&DTST!2f&LpYI~36|2MlD}@DF2Ufu) z{Qs=5EW3!4DyqZ(Lj@8SO8N|opR=L@Y_!2kIk@b8}e zbyf1iBJ$Boei!}O(y!s=@8Z7nzIXako&(1ze^biea$bwe$4aKR_vN!bA5TR{^wr~C z+*?+pwf`Hv_B^E!MjlbW_|5SUdFSbKxbv&w)j50pIiyiu)F8$JuCXeOg4|KezliUf z7`a6bj@TV>StJjd?( zfzdeGRjfzvJ!lpba>svjbhm}r@xj`}zV@;5Q|dTA7vq*EMPj$MYRCNL)slLq4!T+s zbM$Jt!tcGkX*Eo~bv3JFenVRl1deru$~s$LcX@Ch30G*wt`lBOZ=L*eM+ry#uFjOF z?DNLz)Nau+f65c0b_AB&|XLe-Ah-sM^`A{RLRH+<+$t`vWfr+8G>g**v)6TB(Mh7>e3 z;zTUphy;?C6G`DeU5E;p~iMe7Y|Cf5s#Vd67J)V4kGRnoOYE0K?N z@kY*z5TTR*OeNN>c}S^{VUc&>&2qgnY^YAU2|={UfJMr?T3c?hW$3JpYhd-pawV{u zs)#G^*~-ia+mhxI$Z~3nd z%66r6Y{Q3?Eae=n%=O6O%HOLw3_d9FLhy$4klRE4TaR!d|3lNB$1J|8;-cP6ZIA1z z-E+|s8DpKa=eoL|pISY26z*^6SqGLJ`@MK>dgwXhJbR^(u{>uyF!pOrtamMrKNe`2ti6cT!mT>1CPfvI4 zzm&4=D*ruUx}7HtWrpf(k=EO9sIAd9XwKd%UF06$$5%+X7;RFC>07xv`eWwgo&0Ye zk+V`LVp)PRNP2}Vwl&EA<{x=+GbCr8@~~H>ncrDCAY`3V#=d|sC@Y28*(@cF6jFkQ zG>tbQ|4l9YN)_d>`b9%xf7j@H*lUS-u{hTzWI%N@4hiJqkNY#key`C}kecE|E^>zm zPqC54o||C%%H_Z9-cvzBV{40Th0|@Hqo}1=P~ONT(LOx~#+G0`loje5ZNL9n`R|^I z8GN40|90}7l(ZMh{|UgOYa}e>|7co*Qc9jyM?DU>Y|nDQFd!TUcMD$)ck;gb4k#Tw zZASU;2`VA~+qkOr_pDN(=;Gz2S(3_cZW|kD-%hl{GUbmY%p$lA^)YWXUSJL z=T}}w_xzQ5foCf!yn1XJ9KKK~R^H^f9q+SaN@1V9z5*L<3SNT5V|3cEQLU%0w$B@6Lm1L~7 zUk$9oDLdr9v6TPrHnx^|hRM_;{C6+tp7P(es+0Yb+ zcecszzvoXibEo{D&XcFn&xE?l|7k!dx4Zj{XHCr|&KTOJd#Yeu%3H&lQ)`_>YR}J7 z{sa?7Jcke*45b}Rb zN-+e`i&1AY>s075*Wk`71*CyAT?M3zi!n6_QetmP&wGQ@aJ}XKY@nSD%(IK{bE!U` z+ICXf-qf%p|1Dip=1y>=A=J=Z$p5|4H}f!f;3)P~*%QnyEgZ;I`F{xJOAY+)4V~=& zhx~VU;E?|Z!PT3ItNdSqEZGDVN3v_)YG_%K|Eqym`7d1$NxZZKU41Lh_AmB@x=n=t zXXO9!(7e3=e;iLC|JQ-_{h_q-|7fV3%m1B)4RF^1(9Ria<^Rz@81jETVV?7{t#AT0 zn~RaR^8Zv~y^cTS|FQVv;oR*=(^Hu_YG+>-+xO7iL}pyv5vhYYtQC}Y23VMn5uNh? zq9p(K>mmOS0gt=D*d<`@C}7wObsCukX&^-Te`w*-e&qj&yxD~OKLqYMnc1;3Fkd@| zRQo`;Q~CSP$bV&u^>zf|p6xaKmgK)Xin@2D=jS<&a+KLdjYIzXR>|(EaE?MecTNk6 zlKl63=V-`S(|F^ovR}LCPblS-8I~V;4GsI6^|kXifom@R-KDbwj+u{F{&!IN{3PqF z!5rd-{P*;(8MHh1ZJ$PrR_Ns3`L)zwG;oDQN%a305~BQf)aD*g(`dnM#J7*+TyMz# zcHRutMgKpS|9itj%KxR5wja6f4}a_rJS&h$)8MAfK);#rv9$7oi8F@T!=-T0rqtJH zBWy*I{~Lkd7QF_zH-G`pcpHO6n21!{M2_x_UW2rm!5gL9IC>MxVf%wabE|1{8GCz% z{9h0MI*)cJJRb7@1Q)Nssk;G3F8@!0oA-y47sLMt!OJ24cZZu#g|An`;rqbr%c-gI ze;apu5+~&U_Vnf2Ozv%9MEQRJ++_d%waNdjP+tlB*0O3V|F;ex|Bof!rWE%&AP9E~ z7w5cn_W#cT+Sy?HoD`Clu%x>Sz;kEe+J5E#CA_)vHOT)nq3{{Z7M@->iKT(3u~U=s z|5WBPKfv`((B%;36qWzCL#H!=`EquD>SAs- zQopNNJk?fs0r<}b?l-fTr-3=xN0`_DQsLaRv;57_So#0OqWt$H`s3OC{MjV`KTX|U zoBV&4_WB@g>{r+hDF45V^}sLTgUgHZ|Fg8Lw}8#Jrmw`8q17&6{Rd{*Uxxob&0@m0 zV3~SllK+oVC*}W>%mP0K)VHSo|09L((*{1pIa^=G&f#P%QbYcKn|AUs>U1i$5BC4x z%%1r}cYWpmdgOuz+V)9G@_!{^i)e+*krjLJrk?ifTWyA>!fOkF!BYj5O^cA~o+&Xh zjjxpd#!^=AMr)Hc!?>=6zowJZ?z{{6U+QU9TMzTximaRl1nX1(A(#KhU=_0pxqm37 zAH#J!rIqCWDyTA%u-7H|e=yMQ1>YY?ij~NnjkK3-NvbIS*Fm|_w2NH+??BET3-6tn zVk*u(c#2EYiWJ= z(ta$}kNzk;@L3QL5~>X!f7JB0jyGa!fjKOIgQs>|j7yO1w4;oBFmpV`6h zkC8q0|G$ys|JT?9OUnQ6Qy;&&kHF2};q188ET4TEoWH+^ z{J#!dzZ<)V?X;E)dGjXP>oja6Zl_%+|1U)Pyq^+>>bBB?ULw($%#^pJ1|1DU0r6~XZ1N)kg|MRn9Sln#LUZHjV z6-!T*|9|8}y^q5)KSh520luD)?Z}k>U!Y}vEA=Q=7v^LaVA+z(|L;KIkpC^&r&+|( zmbGOM^P4I%i;6a!PD0uPn18O zP4efqB!8YPJeuUsS$x;;;w+U5`Nk-JE~Dj_m%ZjcQTF}197%9r;-3eBCGr|7{Q39m$4HIfpH0~>3bxK? zS$Ni$e|`>(FESc?cj1t1Z6^P$%jBQG2d=kd2hx&n1B*4-gq@Xr6=bprq2*E6>8zRd6#-#Bv*+BK^|3VHILoJPf-_rv zo%v{o<9dbs96~L0v>4D5%N(5Nw;VObF^e8nW>M4p{1>%Hy`6J*{y8t~U(9cshxQK6 ze}zU{oq+FR1&|tPp#03(1yt#51Z>R_FbtF63|?2sloqB3sVIDtC8)Szb666JwoQa z&^SXbUF9w1jeKZ5o#S$oJD;4V5f0NjZ)Qk;{O@eGxk!D_A#gS7B>ox*clN%Gv{Klz z+f%G@8QQ?~cEJ_F|5NCf$^TQyA^6{U?3kT!olx+uTH|L*}F)dkn% zR}p&|II3ZkITIL{P!lyBvrwy;XA{4-3;tK8$&>Pe5X+NtUhuzC z%z0jCN##auP}t~&J7t4B75uNJy|;5!rt^PtrxH#M9m)MT;>tt8|DIZ_G*Tm=<&bt! zVQpXvIm|g&?Y?@uPH5xF9`a@N)5(7cqYn9B`+(qo=goV& zk>nLEczIz1u*m=W6#0J%qmrEemypK_o|Y27#Q&ZL!9Id`Yu6V$#+Uz>GP2AVX{l|V z3Y_x)KBU<}=w`;6`@&zFc-lt2Hi3_N?l)6qJWL?M`KEu%16x$Q=Zp_rae}%yWP< z`2TP;rh7vB!w5B`9!-(*e<^Y0|0BTf2u7yOl;4;Cl{|jg9mP)sy7nZm}i-bAaM3sI(sJ z9LZ>S1*s24r&9;#HNj@j%m0@YYp@Sce+cd6-HHEiLzAxl`vk5RgKhc$op9QA zG#5GlpW9Cfz4`w(^!1+?;5)KXdzc-w*mawBK*OLH)|Mvxg6==f7QPvLL zAC>rj56bPI|4%}1wSgImL#XM^=#6hHTvz1(%fQ59bSrO#3+JJy+67z}k?T#|U5$28 z`F|tuT~Cdh;o-}>;m&WigW=twjQsyX;{OkjR{np5T<=Nz{}pCEO#36C_yOA1^_2Q0 zbP_8HpDXhJbEJO;I$e=x+kO2dx~n_U{L(zp|B?V4A3h7ga7{*TCkrLre(X}j;8EGlzL$HFX%tz|6{X%h5rx8 zE=G$~ll_rebY$}XXJ{8+hqmXkTCcbBtCjQ5<#6U@iGR)_#X2x@BwQ8zvz7ACg==&E zc}wD-i@W(}XX2j|dS_1_^3T=GBz=mzv(bLN3q9|HiGNOKz98qH_d7MS!&mCwg&oBHx;Nt^myS6cdAb#%X#?KGH&u?kp zwy*c0LtYAhiJ!Zm?rnv?LymmdO?7*@wHZ19U=cqrv6l1c!VX}5kgZm~fdsx64zYc; zXGdpE+1BhgKtCfp9gW*R7mmojTR1GckoRxM>X0pafVp4y%Dv~Kl?xx^>G%z8LFwK! zKJ`IG&&;}?90M7i&@V(_H#BSZ(2Zf9=4hGL z)Ny1r&Jku{-qdO<)Sh_ip_mKjojQSV*2VsO;IkMw;KlyE*791NJH`l2LX0!aN3Zi- zyr`Mh?)Lwq-s$BaKlzEv?s+1{9iKQRQKJ+(H*w;qM(vCcxE4fxPhPu0GEc8cye21F zYsX{W=Q!{=LSiIjto&W2+~teVD@5M%xLg<%HQ(Tu(0t@NFk#B+F?b2)rfyJg8pn9@ zhB^mb;KplUPfA-iF;Pr6C&ey$#lozg0%JJ>#Z`P(d z{vSynN{o&o%|!a?p5Q1Y?EiQ+vsSpe692aY!9>b*ELho%qW`5#al9hNO+A&ea{f0L zEhF2=Q~n>%dshnOW0p!Kgl1N(iOzx_l|69QGFzOuqujWB5t}9>ERj8E-*%16chO%8@=2*Hq{uKYN zbI~GmB00iPHNNvRMo*h zpESY$T5pe~PaFKNUScYJpEkVu#Gd@W5}c~ls_aJ5JD2}E$zwV-Dd+!rz^Tq;7Gnv= zl5>0TzayW@E~J|l`OebB41hSV2mTBU>C}bE|4JNnWyTsB|GQU}@<2UN&i~r~k0WPy z6_exLmq-40)r~g)xjafB4EQ7eyJw(UPcc!>|LWyj^D>UBEB4fFxDS%MPYs3tr%{Gh z{;Ppb{$B>X?nO0*@nZ1*d?3)mc_kdSgr4mP-d4vyCH`LwgridrUTw{k#FMUnQU1?{ z(!u|mfn#mr{|y7;r2IuKBcq)E4+6S%jHj28ezzk3uYrFz(}V7WPYYN?1pgn%xUM?* zbN=7L822DxJ2~l#t0j``TxYk|HqI+9V3TR z!OAX1_9rI(zlgH8Qk&7#@K8#rj{m0siCL9t6UdjJkpwnZ0t2~`g zj$gx0bUPMmZTPFPO1Te;o=Lpm|Cgb4b@E^Se-6D$Cy?KP2J99zU*7`1SCHqA;QwEs z8#|HGKgh^e{=a$1{6CXi{3p}ZR*_(a2+(6Qzie%{|8Z5 zHMc9F;qHn5wU8?D|1pXGPlQYNp#0Ia_x-`vLDit2csc(cO{+fuOQ5U!;s2`>|DOf7 zwnN)H;Qy1WgkS!@xyb(y!Ann~0Xh@g;2W?l(q38q|11=_9o>=q|1ES9XF!{3`TtQg zI6tALA40E|p_6%z`@6{LkDO@x3|iFT*&SeA{{MC1A9=SK?aGVTN)46&p8~2sqrKah z9iROj^8aS+97keR^vfduYr*^!n12dN56`OS|Kq`A2h=R_&(0$M9E=8TI`2Br^#uQ% zO-&AyXDMLp?Cb+OuaO|f( zN0>r8qMeh@6nXu%LoxUA`nzJ?eKM@Sv%=QZ*=EOPI^lG_*|mbMK($wA{T-?69Q(Vb z-yKR~e%LzN?;qvs6gQ}5xsF8CkEv~Rq?XrTEuG^6byVuu)LsOBwS`eDWj!6Gswoiu zy!YhlF!z|X{_VVRw`b>hOZ9ig&|aCl##;Zdzp%%kv!A_yRMSaquX{TEiMf1F^7?Dp zu#Awr{OZZ}L5#)trFh{8tAN0}Ru3b9R_#cs{*I1af#+;$23~8q zbDt4i)Zg)DGf+hRCllJ4-a6a9iYI4Qt^X`?x2La##f%hVF|fHNu7K3s#NAwaKaDAM zdHvTRSKEnk6!kwC>9~J){kJ34PUX96{r7=wGV;QtH2m`Yh>D|5ZS~g1>{2ar2?S>oM)y>8$@A)c;88 ze<=0eH`V`e;vJLTUsA09R=(@+p#Hm<13RQw{ja8PWc}a8*ZB?fgm&-+czu!opG9Jy z%D1_lUZC}VneWg0>053s&Q;Y=*AJ)qU&nkJs|gLI1-j^BTTfD}euAV7LCSr~YrCAEEm|ulj$2`d`fm=1vbH z#MNhOn5~)syrZ+p%-a0FtRt}gw-ovRhw%T^eAWLKb95WC6SL0jgM6EI5ch?YUaNw0 zD0L(D17{@o4+axgP~)6_!hbr?O<+#=KTX|kX6EmrlwSB}XTm=-+Z$Wu7nz|No-Jer z0te{fULybBlKoKdH%mo`5&C+`RCt>_`akpp+fmn0%O3R zkjQy1$_LZtu5_1&^uESdMR}&a$@Kb=@yg;#F7$^bUAfZ5)XGTZW+msS%`Z?c)0O&a z0G*}Czd^SYjV02i2w?^%4SrN3V@zY=OD z2X|_w#kbJZUW3LLugQpniBfM`m+ z9ku0JA5S8!_EPqQZ2y&YK(0?Qmh1M1lUnU|(0>9_xpI1OZ|}tQpew-NGQNk>e=eBp ztcw2b_Ym|~lhr|*$^5Ru4~71*51y2?e>H-%?nn@=V=(;r?bS+G$>km^W4Wr?mwwgJ z-~A8jNHZJX0Mzd5GC8H6MGlpmyO5|2$-vtV-TA5N)z7qqmL{=OO9<@Dbp(SJ4cKdDInJ+WxoGI(O%YLgfA zKazgdY4m?(90UEg0r|P)dUnP1 zhr(%&w{#r&g8tWl7568oO#e&KHEu(9aTj)fr=Sga47}e?ANCyRe^s)(8XSb2 z{tsedqfOc}`km4KKLGt7A3QN{zl^3N=>HAq|2K*LFSAZK=>Jm1^lOkZ<5RzMaiagK zZu;AUu1x2K~+r2l&8e>|g`y;A#kmHdv1kfnZU0w7|2ydYz8)>>^;OaT zUg-Y@%Dn)Kq!Rs~ML&2hn%lpwSpK1mRc=8e^k^CVpJv2xN233?DyE;C1^xHW=49pc zpORsjmTk`}Ww3@(LE!(~WVLv48U7E0uPV7C(ZmJ*uc8*$7V&=`TwNXhXJpTVw?AUF zC;q2pzoO<#vf-Kd{|(yIO758izvGU8|Bp~l`Ed_i@NKLME4lI6F3xZJ74l;rMo$6% zp9@Pf;s411{8Jij^hIxsKrGc!MCqvnhrOD}!7qI85r$tt!?fQqhtL9*Qpa6bwUlg@ zO7HE9gbpcmHTI9oo%$fxH<*LkGWB8Q&KkLnF7}J-{|lUJ!mLH_{MA+E`mz4%A8%u& zk8=Zk>mPd%JDwQ4{@ONZFlG}Pjfc*}T7RvA7p1ZOtbXcmKV~6P)cVh$AK2TK>aRYscMm&u*R}U${l^SY z|LN3!8j`oZ&lh?I--9~7yRJH_0m>P@irEi? z$^GVH{de-UJPmzQZ~E`WH+&p2#rk6}+o%3*KXyHnQxFe4}`OZQIe`ET* zchAWc^f6pDV*U3oB~5oTn9ZvLhU3X$9rX__SSgbARiATms{fIF>i<}({|&|Zzr9cW zAEW+nW!@yO|HY-O)7{4@`=-L*qUE`jZ~L8n>c6a5|G7|MF?8x%|HJ4tM*R=vi_*J( z*Yl0In)=^>ChuJOhj;ZVKkEMj?6IT%FZOzG{r|nY{=eu`|Kl_1zdLhW(tjOR-aXy< z3I4;-c+IB#3+Qw8bQdx2@=y`}r-1)MJzrx9E&RV^e}!Glp#0B1@JIgNCjSqR|L^OD76<2&z(#Bu@?NCnZ^XL37!b`CuJmTi>@-(F!^VIPs&%5_Eaxren zmGbb;uU=e@5nsSkY05(1`&$Z)=aQWCo8q4_^4Rg6i8v*wN_RPAhV*oPt3r?9_cZ@< z`GtsbO{v~M4N&B7JiX31#tco8SK}HMS|)QAMxSF=#J55l`A0rc0xwcpuO+AUEi4bs z%Y4E|x$%AUn;H3+Aha&_-Tl(!SW@Su_A#6=I7gum>%XX%as2*j;b@34a!sYs_jKy8 z)JEw{=Qqu-i)jp1>t($RGc?M`$L-NiF|DOo2V)DNUx&!SFPz#o>mT0K!3CwSUqIFu zKI3XfX%6awwCok1k*C@@>lUR3uR8bV*IC?!Ri`QJHCU&hbgudHOK!c?Qu(bje>Fyd z>7cdW{G76V;d2Hru&k}Ev{1Kb3T^4kNn6(ViiYK&DU7ELoV5!J>X`2geW0sUg*JMJ zLKo#)k5~mQ9>u7bw${DBas+p~z@FOQptX6$ESEJFv+fS5p3yas!miFm=;b^6GQt}c z*w#zFih3DCTw4PziiJ34_N=eikN%O^jvDmEU&sRMU_K!cjFoeXcfl({V;pO2n18`* z;vx5jh8&1^rPgB_bIY%#G7Q(}zv;I4Bj?9^`6P0a3c?|Me3!?NB8C{tP~%0-)HO%h zQ5&D-#NZsIfGMIiO6m7!5+4) z(4DJo!!hR{;~w#=K1M#Y<+m20@oWiaCCnjcU@hEB+ZHvL{IicYxct+8-!|-D%$>y9 zy2^=i`R97tlKgYuYxnOC%l>lt*FuS6-dg5zD5q>-k=NbM)|tyc@nK6HNjl|)dl%&L zFIua3h!x6GN()@quZR3|7w%Z|F1Of%#i3!&P8f3>PwootT9laAb|yT=JOj~J&2&%s zr~P)wKTq-v`4?*hTs5rIqB`WC&%zt^X)Wr5T=Cyi{>3Ot_>^6)2Cxo}b;R6=1SPlq zxY+BwiIkI|pZk=HwUYdE&xc9WTI=M=y!FHocTpHgsGRTVtnEC9{2NcW@=xn{--NA$ z78>pvTath7k}X%cdxWQ{SC)Tav7+o!g4im;`x{?!IXYTo$eEBm@twA;@V4k^xgkFc zmv)BP+CmCM-pa6$=pn&!E-Xi*aF{;YZb|-0A$ikx=4K4JD*yTh-ObT2gmOnNcFx8= zhNEEHyE=-HH-6jW>lb-Nn^i8D$H4f@XAvALmgHZ^jIeRh>NIw5a9?frVsNfMmw&dP zfJGcRD-k<_xKcq0BEJ~ciy?c<)rJmD)%Q*(;)H1XU?t(IpvZfI? zMR1fq4cKyIlTF$1W4z`cC6pchK{}v~Us`=E@lfRpIgS|(g1D!|%+6(P<9Q*H1NG|_o6U$tb ze^Mdj-+XeN19UT}^E|j@HYwZ%#(l3B^VCRQLd@=k1LDs$j&is>Yg>$OqU+*fKk;1t zd9svkQ2YFlfA%aqoyT~}>yUrW4mrbQYqj5GOUZ!2FxO>z;)QGY%wKt0SaD}A?TT!V&R2WtkUeTs>Ebut7Jp_yIrkmP<=+J8AkTQRMgi)WW-j-h72_!t zA^+69>0ALMzkBk=SXzeiZ+42~T($B~dpYONX7JQbNy6NaT8w+ps0CAB=V~rpU-;J0 zwmM1O21j@X&Rm|R!)3G3Z`J5Nu)LhPi65$nK5voy9X7>#q}AwzVK}#uLZ>4jkL z3hL^KJGMN}c$mYzHuNR=w~|=Ozk|_eh5Xx}RC|$gMv7@z-5o%TPF5^;h_1zqcS%669@<=+wLmzOe|uKd#m^C)6PSTObMx=P!&MN<;sBJh!8pH2Fpt@5vv_k+v7ZL~s9PjMfrMp}I?|CUqIyab){Z!dCM z4Lw5sEr83Ff7-LGp)Ku49(ClQ{B!-z8lF4_Y9UY4m@(dqn)Z}`2T{+xXi0}aapm9U z0qJ`lF;7IxulzfX_ILu2DF2Q_CT#!@`vdi6-YNg~r!=W?BC%fwKPmstB*i{JGLDda z;W*DXIjAWAPKPJ=h3*HzYg3uaJdzxaBzJd^IulMkkNmci_yMSDT@0HP)l2fyOm$SuYKo`f9~j_EA{{G;K?18LjHZB zINR_(Xy3p5dz|n`n8CP=YcBuXZT@DS`*+uauji@V|G?^S5= z7^_qYtYQ1%fcW!kx&XeZ2jfej&P*U!o8+J835Ywc z+Ou#ky2ah{Z$?r6%>d)t{H%tWvxwP>T=uM)J;1&4&+w3Z@mr2bPi<)hOJ23V_lzOs zpY3W9SUZBeHvpsZZyz96{v81B+?#F#&@2Der~cn=;K|+2lz*#}{5v|yKfgI`|@Tx&U-a&WGnN9i{RwLsH6SAQ;{*sznf@P_Z2#T@8Ut^ z-`^7NWo(X=e_u=T?+$SOP?CR7CHeOT+KKY-9#((J$JZwL_Y%0i6K;5wbyQEY?knWq zcUd8+{JRYr4`YWa<)0E_C#8IzJ*)P|PfwOoXR@Er-*(Htdk4hdx8e30_Cfj*ZQ^0( zL_bZcA0bDc<724&`(fdJR^x^I`)ZPZU&ZR@i`ev(%fAPJv#0#~du+6Rj{Lg?c~fAw zq7#AnRqFjJ_FS&aQvQ7ftk!e?>p|q--0UDu1yKI|1pWy5_g$#FKWhM%WD{7+){^D& zZy0L>{(yCj^6%f^sDFTl%D=hUpIAHgXXM{8*!LftW;Ry?)3oeaR*YrYo7vfE8MS>Y z*e%JwCG3HIIrtb{{=Jd*dp7a5AcfCE0-p?C*22ZpS%YBvJr(Y{B(>iY;4b$8JrmBn z2p{ct7xMc=IBGpJs-4tw7~hi-z`qF|JPDq&|8f$t-S&G4yg7?nxMub|c=1hemF@SE zLE7&{{j}d3Nb@v2b0hhG912DIeFxTbcOtvqk=pN0)@|Moz0ajZt%pvdu)4bn2p>xA z_dURM3f5C&srv)863-sH5d573FTW$T-?tNH|Hb+5R#FYzewSvO;kc1dsgYgyOYOIw z6&PPE{0^w1|8gxd{7K@~6~0Ovcz~AumBPgA`>Fjd%|5_BUT3oc)b`uS(*pLDpPWVe zU7SVx{bXvtb#TK$Nb|+nFAD3k4&WOL1OvhMZ{76$r$pbMg6(Ia?|nV!dpqs-$I$n! ziM~IF3xAGn;nT?q;75tRpH1}rQ=;$9w5l(F+n->;HGww&6KeSx+W7xW^!*Rkocyuy zPr&-WpiL$EuFMW3{@6_U{BK41yp_sakae&#+!$8W+(JusAG!lF>AP2U0M=*dHnN<) zo!NRU=|&Zf%&ubI|FrA};PnXbDt*5LeNP69%d&q?^j(yFjC_7q7@6&#olm))>^UcW zPs;|vALuPQXM&=K9d~*7;MbazCVowy&zB9Js`S>Bkt%e@wLGa8c`eRfPU!l*tIny9 zj2St#sOpcM3kqyimxFWJ!mGZ!mizj2UtL;zQ2}*6{}lRc^)=NxYaDaBYVBeLPGGg# z9P)T!2OvDv<4^s4%y>B`W)3lnm*-jOs@~37SgGJFc;LVK`kPiwnYyW1XDbHOoK@$X zyH<!bFMdaZd<*(I=_IU`ufZ9_TkivO9^Y@ zyy9zdQqP&Eq0rxXh_RGusnXxEwx@_z>tZ&}y?NAnx~s0c&{to7H3hCN9?o}9J8)-w zhC+XL0P@tva{3Q8U)Q@{>UEuoPzM?GS8LJR>almK((^RZxdy}eIdv*(OJlupDb8Sb zuC;NUi~A?L)4IAE^)j!;Sr2!fa<}hlooj^`fW4{oe4OiO0PWh{`> z-`S9A-4e$5E%a`J{&UG?GUJ#z)h4H>sy@ga-{*n%xlmJ^*y`JViT*Q_zA2-3xrA|E zwQd??FzLSlDAvCQ`tQbAt`%L6^mjxm{WqoYU9}LD;?*%i>|l)IZr9a1H7g645t>S$ z&%J)y7&+|u8tK1^REe=@zg4T=5-(f*I6hd-GyZ*QyBforpze$-_8#Xgj&~+Kmn1d^_!C5j{yyEnGrhtXg*hBM|9-He-s{M*lA8e=WW3ljyMq{onDQ zqW@jcpFU}oF6jRbdfgABm%1UXZh!X>>3;^Jc-wzY{|^m;{$FLR`v~;Eh>_BjjIlol zHJ|6VTDP1&zVyE>wf_?s;qApL^6KgTg(Cf5WF#g1KR!hI|G4n8BK>~|_3lRJrTka# zR-N0e@L!w$_S8!wml(eU=JL>pVOTz{$I_vO$> zT1P;p4!8o^$kP#0DQ{!{WnB)db+H`#un`tEcQM}-b&Go~M)J6MeH=>#HmZj%Mvazd ziI(Q*DQt=Yg1|~C=b&$t9d?#MUq=s)J|oOLd^WfEl>^Kr@LnB+rWP_sHI7rYWAYj$ z=KPaigPz-0X`!&+FXv8}yv zeAdd*bde_Fn%WVLv7?1MdW&4NRuUUSp>VbJ5b{_RW?i%}viul-`zEaC#j#=5*?JgP zD7_PRTG_}0)wg-*z94MGsD)-i8bEw&I_EC_opImD>i5$hKC7dH1wapo_6h2AjN zTv{9Nt9900PEm6a`{U!o?$Dt+B&SG;N2Bc5vs5t5KET2qNb z!;GPhz}%{bPrE9yA{S}x6m3+S1M8{fRPeSEOn8J?jf!>BqA|Wyp;3^!I_s)dRg2K5 zt6GP+3(KqO+lRa9J2PXR+HyJ;&gGvFYY`B##(3Iy36~TKdokr-v`ldn@=ra4{HY$u zUFD>VSkPKa9yETnF6@!DLJy8}Y}`h!!G&Qx@2(|UxM}O@x>D`nLjHyAdRS|Vb9G#< zDXmGr>Z@YUS#>^2QCq%NX@7b7XQ}d!cBEQcYgZQXPrJC#K54IQJzY2I*=btVc@Cm7 z!8>s`hO0Ju)jDmf<#Bhv3;S8Ev9ahpY~ekl&^@o+m&efR$5*4s!CFqFUyem+8yTd&wcYe z^-OJ@>xd`vtZlcJh1z3>{PTo1<)6D>D2tRj9BNblpA1glO z-D;hC^-rfPHJ|P}?R=_s;+8*=XU~CC{%KDg@=yAf%Rkqu+cL}LpDUmzQp>>z02C*A~ zNBK85;ZB(|ApGttwC48AQcr|b{<&+u=Sq5#!UV7;kBPe`QpiJE^P6%k zsidLnTs)7mj-1@#az58w{!Il+?d6nzbIGAvCq$i;umGOYlF(f;$AgJ+lrt4rwKP}$ zX_fD8>7Gm33Y2rHm-25GIGRU{Mq(=eJO^MnVN2jgCEZfmge}UJrp@w_6k5IfTZo1_ zmw)qs&i+NnzxnWrej+rR1wVS4TOH+%$wscyf$$E!}Ni+sP%sJ%L=5 zf3rw26#3UdiY1h*<&qR~ugYa;@E|dZqGjj|B5Xo)>_z(d0fB z=;VI)aa~GTGof8B{}xjpEun3v+Eup@ZyFR;{;h;2ZRlHAkj{#og-%_#)`KJY%=hn;z>V=f;E*f&`JnH9O6^1l&?>@XMNUi+Siruh< z#9R;mX*Iq35auTqpbekFj6yE|HdAxupL-qc3C^?=Z-CI9l0-{M(lj{_^r~cc7TT+{9>X&^H6u0l>QiTq^54 zQ8Sl+2Z1eZ^Bb6jQ2rgv^E6;<xjLkTJmB!v>Kc&XHG)-r-k;!!Um`v^3Q#` zv^iY_hI9G16mC115ar)CQqCv-MxbaQbpsYb+u#l5-&*pVhuzU${Otx7_s8lbd0DeSxF_ORQ#a6Y_5lpjn;#LCp3X zg=E+Uly%JJg#6n`IXft23-3HXU<@EDRuNuCi zkqOGb&0HIpg;D;U$$Y|oP~^BI|FF;jPs+cuD61s@j%MaZ`F9MEt!MUT3pt#|-#l!( zc9GAKJKM!cN{z!A9-?=A#zCPsi|X zA~wcX!NDDHsPgY~d^lS>#*ly7%U@5+^n}rKlKgucczQ3eDF5!pABMeQ$iG|3a~@WY zdvUJ8&9s#Vu;#uB_|Br;4@Lf6n&jVeN&ejf{XUW8-$Ue{%fB<29qcLpo&-O4!jDZ@ z=RVC2-*@nL4LoW8@4ZF&cQ-LY{yhS|ub`!mW;dVDAeSB-viy63n(g9@VddWi@b@nA z_#(8@f1KIQ&m#Y{LOur@<|~jRZ=|I6r?WgB=iS5nJx)y1XzRKh4!e<@F6@?n4^ofM zk<&+s{W!l5SKB))C-S-qTXN;!lgx03{QC`dyvn~1bjv??-ugN6?-xM* zUF6@h@Zu}fxQQBkkQEQgzq?ZZ@4w|=^#A@_{uSWm|GVX%^9cE${ebwhd1a}M`5SlT zS7TM@oI_F5W_+(YL*hQJ`F(ns;^uHfI`bIFIir#PnNL3R>bnM<}A%&AeZCbt22XY)Xm!xo#S*S$Jv^g zf5`D4Gd-3P_#YTQ&KQ}Wv!XHUAwHy^seNnC&bheDO9YUn=af16F4j)wer;BHm-3mYaTE z9lfD^R$B;l;=&!d)XaO;JC+c3XGfix(>tpXm>Rf0C+4+IFjrxn*4LdW+@T`uw4L>geTmer3vKYf zwUeUa&b8a|EHwsl@{8}Cw{T|A^*^y+g>zXkcP4Fv|HV%1l;LctwGE!C-d~l>aW>K&Wu1!?BhHn` zFP?7UOp$XAmN;4^XOBI>*d1bq(f^K}b==R!xsV9x)RVS4qs?#?rcEaZP@ziJtk2LC&oQi=bCNv%K8nL(Zzq|Lzemg`CEdm%0(pRhIuJ6EcB6Pd3uVTs^;MS~!O-H#r+A z|Bp{)TetpQ@W1n-o^j<|i`Me;zbB4OAwMnFT_GOx&!f4QF5@U|8hQKdjNL$PBJjAs z&Mfk5LDLufKMg7bE#3RXc?>b+PCT9m)&UHzRdvQu{&!Vz^)C3o1IRkbMQzt``u6S# zGK$f{RPvVp<=9DJ(b?0%`QM!mJiB8iDP}XGmVyft|GO*5T*lwS86~;4pq&4mDeWYU zb7QTfAIMqD4zS_rRr0@Dh9<@>?$hMnF!L$TGkm8}4|i4x`9G8TG!q*9KZg_pxoIg? z2Pt#@7tX1a=pGe|q3$TgyY9%ckSyHO$k~snjJTR8Q#{S8$o~t`^~?sAWz=^CsXS{r zqeS(`4b(;c-;L7L%Fbmh8T`L6@x^?~98CVZkI6c69#78l{~Vs?P|jM$=M%_F{$EB; z%g`OQqj!=2=TqJ)YS0N?EO8Pg4&-wFUkM%drrz@ZT3``co*&Q<)@cMN&%jXo&&|9Dc2N4p{auR}{Xo}6<2 zUjuD-;MY<9CQ51m0@v&J?{*aV|2VE|(JSo>obCdoMt3?|73VrmL(et~-R&ys7W}_G z@&68LvXwXPt2L0T0qRo{|GT>5STr0t|DV{+|68Hrt|I@RfTm^}TDsjyC10GB_JQKxTMmF-mZQcNF>m!o>e?Kv%RoP@IX5Yy*0s!v}=l^QNZ&`8$E| zGITjd^~?XKp&{CveY@rVQ^|EXnqv9?q{RQ%Qm5+ONz}FxsNbIW|5WI=63u8GI=!`M zh|Z;buY_ZA`Tx$u|JMze{h6dW4!jJ91FuW`e>435Bw@Fr`<4G62hUIR;D1-#OhDiD z7W7IFp;f$<^aHta{=XM~z6{OQnat$88NI{PqVLkc(MRdZWSO@)dH~)K*?+RL;^8Y!o^%QU3KPdk{(TD$U2lp4y zp6;bC%KuL${(mQwzmDA?{)YMl|KAAJga4lz2t8;Y=Th5c@bQPx@4kzc_K#>Gzeinu z1$G{1Uc>eJ-(-!;!|X}_BYLkXLCyOLGv53tt$uLtG-uXXeP*EqXT{(lMhehdHK z3b$SX-~KM~|0~`6e?K(%m&E@+rj&pFZ~p(kn*Y^4_!r~N($%|aobf_qWDfr2S|0Bz zJ4cpLey$%FBI_3|fBJ{Hkj)x3KxETz=>YEz$C{ zbQL0XZ3B;K%X3wWBh-##gu-$|_vOg9vJ35(8XE1<1OKt#wl>9;oq7%R4cbqJ{>o9I zV?;wLJGtB*f~842bBe3_oytzlfx3X8zxL$XM@oO~hbz0FzqZ}NZQoX{h*}QEan(9u zmHwUrE&bJp#Mre`4r-Rdo;Xeh(%w`0Ytvgz`9Xir`&9FwO>0hnd)Ad*(0@Xa{#wtf zqi|p4>gX@NJmqF`N~z{1P6E|lwmSN|^LEhRlSH+Vbu2NN&}!({NX($W_OsI8Rs7O_ z+90E*5?-XgtM1)}KpQ&kGPQ1VHT}T7s#5y63;H`=o&pA>zxsu_y`%N>JS)-Pk*ijO z&7>O%2Bp7!!pg3hQM{IXi|C7Mf8EAYwEubZZ!5bFFx5z(Y$o`gO&*=VJyiNHCGDC- z|LNqkGL3R3GP0_k{__*JEvMHR^!K_uFjaP)iT?AGe!#Q5bNY8e|5cTf(`VG~ax++8 zU!?y&^v7n?Pus*;p<1^R{4ZvNF@~J>N?MN%+#Os+@%jmy}FvpP9Sb0c) zt)7l&Y#8)E6dGs|b9B}8-y_lgU~28|lT!*C;J>}WhI`9Za@*k2Gm7+IN1HhdD~w%m z{&sraTPh{yeTJkx5?*KI%g{ngX|t@Pv<)1N;D+n$@a+X)WeJtX?y#rP@O{~6ek42Awz73u#R z)=;O?{-yuv(EpQ+Eh@VkX#Ed%)Bj7PxrVXM>#L^!v+S~V2IDc?zxxK9#i;1VSOtBK zvl~BNxp-iHTao_HVFB`3qW=|KU#9)LH(Dk4OR#kn^#2+58lMOAH?s4X^8XA*hyP9g zO4!TC9Hn>}w=tf`!{W*C7^(Dp@7sK&Vt=`BdeiwO&%J%j$jvu-ZuZ~I-!X&VU{y zBj~%hcBoXo_P(A&?>=h%_|PXsS#gQMfA|1R{<=b<+(y^s2zK#r&2<^OZaaxb9SJ(+Lf zBh>8m;F9Z#Fxs-|Np!GIi|eEeI7zURW47d zmMQWGDOz1V@l{bL6?&=s*KbWVF7z|TjM77|=6&z)SpT^>x(}$8(%vb5{Z7Rfum4n~ z(9ml*H*O8W3d__!2|z|k=XcPO)eUI#WL+w!*EUN1 zg3$VHQb!nA@LMfy2X}tAOSV0ZtlfD*`=!v9Ri>Y7{iVNJHZi8Y&pim#)aV9p2Vvpk zH(To?vF{F<*4sWqWoK-ACTi1i$hDYqCj?K_s^qlTap!|*Khob)oi8+x%J_Hv_&B~% zTE93}bS1eOGBtJnR&w@PV!gCIfS|v6CRfDQ0$U|#f5+8-#&wrUze4U;AXVDQqmt7a zM;jvfMo5DG+Ap-FyeiSp)8<^GCjBQ<1L;2jY)F4GQ7L`Ue-gQ9eIxx{3uX^WtDefv zy#ie8+rh7UWy-mpgW;J@)zN=$k^YuB={3@S0X1Gg$(@P*bJAUP^tZ<~oA0MQw+Kv5 z2a5}-%Y15IOP-aSXYWj=PbK|VK>w+H$AkW}s-nNvD2o#PXLAkuchKY0B4avqtwg`^ z*e~pcPOX;S%VZ$%T=by-LLjM3|4uOO4F6tGZ!d6RPk0JBYQI#?DnPAYT(KhkH+Iv1 zIl7(Q6Fw^8Z!M)SN^na5jYaye<$g8&$|aSO1MO<`Fz)|;WTN^SLZts;To>ajxuE|c z)M6Apz^#e?$5EGK68(>@lpHLT=zlu&-%dX<=zkP_&VlVh@{CtwjnSL_N7Li0p8ju0 z^j}ZUa5Cw3Ci)*j`{~99_hYTr2l7GXLNtX^s7nX zy19#h;%+c;5&kQQ{&&NR*OGp4`rXX>qbI2CGu`yRkM{rNME{4Yp#Q_PxDV3)|BOCN z`u`NY+}+Us@2J_oL&Hk$zYP69niaaPFQdiR!Av=Oa1c?~x&2`4UeY~;|1N32&-KGx z?<3wUu8)xBliYiKkgLu0cibO`KdY=Pf_u7*muaLhVaDva^LxJQ_4E~@zK?S6=K3|R zU&r6a{WtLM=l*5<1KfWL{{ik_;rbo?!`wf@^+Q}=#UF*g6u3~jb}1O1!T*f=*A?G+ zy}I~pU95-kr;&$s_1QX2D#qW=6$Nn0>&@H~&%8LyB;ry=*C~XVr&qmUS4CJV`%T3E zF=54Wx{lype{}d%F8QUjSCWqM&9BhKwIYs*_rJxZUO5ExDjn%@^UJuYmav){2d^1V zaaU8z@W6MY$BY}_K5^3IDO0CS@0dAjPUpNLaGxddd#KMB@V9gSMXq1M--&+_-$K|Z z{Hs(OoEP3p*f{(q(o2gign`3^Ps0zut3Z$rAH&0|i8qb&M&io5&|RK2PS-ZPX-q2} zq^so==}fFDU6v37KBzxqd220>YHMmU{IHhR5hL41*+uW+x}Kq|cT(o__!qeUJlD75 zt;4&x3fpajKMiaj!Bbz~rSP@fujd`ONjMNsxARUO7jNS1GOo7uSMYD(o;Y1QxF4cR z)TV0I4@c#wT~^!B)I9hsZr3+~;dA)!k@R`4tMGq?hsRY(bv;_${ovpV4A9ip*45Pm zQ(5G$j{)m}ZQmpnej^$Ss# zRHs|Hw{HDi?XH)*nwq-0hK9z*+P?W0J^^gc0jqSqiTj-9MVbnCp$VVU_+sK*Qj8BD z^yh4^kgzsYOr^s6xhKSP+jCR}=XFuyO+qNc8(gA{ z%Jo#zU&H-%+@HYxzv0iOjQ_y@iTlU6KEd@#uIssO;JT5kxVZt}N!pvZt}LcEY%%w~ z=bicI@6$K>1;Wk$OU3ub)sx=xj3W$|pWre53wYx9Nq-(`h@Zdjj(-99U5FQ!Vts@s z)rYc#C*?1E`x1w)aVmcc*8_{5uxcGVs2m~V)O3?jp$YTZs6lb0lRInUKPe-P+mEA; zU0){rMXq1P`%PZRGvD{rH|gZMiRWebgYkCF@hObwt~Q?AxylE|A%1#q9{Kz7`1X;E zPo7nSVd&%i$9q>yyeLzdWzJKHcfd;1RwAqvcax z@~wo8#1G~YJ)lbsf3~G0=A{YW@VZ)vQHQIkv*p&*q}Gen;=i_z{{b>SkMhsw-Gy8) z;(8W-0r&FrIb55I&)c}y^V}n>iue7+Ph}MI>%K30?hYHEyz=+m_k+OK9j707eb?iC z1JC$WU%0xf=nWgt*5VskCQh$G-!|pYbzzwx25Re2(yA@msi8Uf$1rwT?QC z9yej)DYdMQ`>llHR;FK|`feu1lP9H07}f6Mh__@59)UYODsx_-*_|CpoBy5gn# znui!(*EHNt>6o$Y#cuiRIVnx~&rQJXci_WZ@8EhTSLvW^SzMit|4X@IHT^2qHy{IATE|c7FYiYPybT!M&GmM?{7an@yj!_{ zlzU|}bd!mWiSeD6u2vsVbvYT@*2=H84c_%|e&O*c z>}UM`5?>GQ8t_+hZ<@9EJ@MPg&+p!G__Oh}+4SxHI@eoy9}eW>;x|Hyzuj$&??)PY zPv$xsKMg;FJcO09%CD*ab_ro8@GczC^4-gy%CE|EaEr<>@*z^!6nrbs<4V_5X8t@Z z;&+uYBzrnHIZk+;yRM&e=lDuoT!R-c;^!Ii{v>_}_lI+p_V7T01)8woS@gwU;tC%m zSw}n6_3X*^gS3bizkH{yc6Zk~bJS2sZA!gN znC&jxpLuooP!IM8%VE3YPnFFTC}#YH*1n0#%l*c^bp-e9Ll~Pb7W-g@I9L zwi(9fQd~mP&GNhY^p?}> zWN(`EXe(<%kB779JG^ECs|fo;oa|APp34P!^=P^GAPt3T#fyA}#lDqG%1atAyl78{ zWU{^_0eXY~U>SHG?LuPXkGEL&7Ze1%i%PtO%a$%$p_eW$TU_GxFZC~3sxMx? zs(e-X@+B*lmMvSlYDI0`)`q6$mTlX2wC=oM*Y1nk+RXx#Tr4T|GOeJfz*`zv$0*yVEOVDD^_y$Tdb9oaBjY2$Efi2rLdPU9x1!vSlc3`Lf{h75Klh9RF9XVllEh zC7z<uiv)-y^FY_ zS>#78R+g_`a~_8jDuOofdcA%SEyC<|jzqLo0n81{qOwxB3UXkVjpp@XwN#3xI-ZD+ zR!ygRJ0l&&$aEx?7%|%SHX4_mKUyNH_-7bXP20A|t4>Z$HPlv3#iwhl(&N(?vLt4Y zB&O3Di)eFI(nw6l(!lSo3YnanYpRHY5F?h1w}LY--&FKOZ|^`hpTfB~RsG2C{-bJS zbV}T)s?t6)R&)9JqgP&7A{pI0OrsuD)Rs*5~1#&l9{%VwJ8+tti29#vJ1%p!C7 zTn%crXVuKuKrEeUk7s1NI#Qj+leL0IHD;sd(PysQ7bKQd&HCHh(Q!dlXm8(vnyMZ3 zE%gmmO%08$jZF>Pt3q9|(L^d*)p2rs7L6fu>l$maxP@@>@2qdGpEHC1Z_NK|^?Q;3 zuj}9c-`np6*>}$6@*?;@xCJ;R<|Jor(j(RmdBnhA=ipcFzHIBK@4n`Pr(bvNO~$Ft zUvs|k;@|&6Ef5f*6CZKLBO>^X;p0O(iQlX7DMOmiKYof&0O{xO`}0k(5u_V1p=`&e z7U>9nFU6+?>7)3K;?s(B62DjDvkPgikgmmN57KAwd$bm1lODe(@rjTIzpYsJ4k5h< zzhQi?KstiogZLaJJ$|G3j3WIEeoL|Hm_WJ#zuWLhBK_juxwQcH4@4o>dU72B7A;Wt z>Og@{YZY2VTUz|;r3EG0ZKB|)CkZ&0mh}7-!&AQ9)1VzSVbTqoX^W-^F$PUq!;9kw z8svY_->wIpYvqcEJmQOhA9mp;f!pLv7C*@r>Xm-Fh(aQ zjgeHQL8OHdpGwZ8Vn#B9M+aDuk3=UY6Caai%(}_sp;q> z=x)>~4j(B|hz`$KDi*`zy@DxQ*6#|EiFEvgF%<(2D^<#0QJ73YjC_)ELt%0zlNREE z!c@#+dV^ktJ0zVJX_xVO1UBB;!ZfB(Z; zfbYyxt`FIY$xT2$o;sb2C)|zC;m17UE!?9v|8`w`VrsJLcr2BUC#H9=Z>(=vUlp4k zNsPv)$9JzkFw|Aoy1pu%fr&*YvDLGC{mEE*{lyoR?24w-v8mz7lU3lKPVZhnlbXID zJu(3kPS;JvM^cG&Vk}cPl9;+6nx3jZ-nhPMDmon>!w$nicVQQmR8{TDq-N5Yp6Ri~ zISOlDPc|^7VztTj!OyYpc8TU0dx+karg8X8(hW3gEC zX!BUZ%U#X$!gblPpdQWJ8k<{(cSh^BjqZdVW5c6$t+A%jx@c2NOG8uBwy~Yf(f=Mj zS{Kx#CE7IB)EaB9+txh1v#zD3rLk@}x^tv%bo1wKk77jBOun7>(|bnpDXv0~YwgyQZ;WK}}j?4P!f^ zjZJmKW5dnpn^pMyt+l7IS~=>K%7MSsSme*%v{^ZhCPS89xc=HJm;)jmJX zM+}^zzj(-^kJKsp;sxpd46k%kzDd7ud;a8GNhPL1GB%w+Ix9~hF|7h1*Utnu<bOaitTO@Wm{*`sjcbM$kx%=@XYvDwPvYnu5YYwscYPdCqJ0WnAojcYt@ek z3nZ7K&tl60>Kg0O1jhE3t<-#Us{-nhBXuTcRteZ+n>+k^d_|Zdk7GWT5d~D+$OzAq zh<6blpI7G0O!HYhqM)*8?5RWqxW>c#y)Hw>)eqm%5Qk^s0zfW#pXhw)QpjATwGV}>aFAhA}@ z&F#J-UlTZe#@+)xogz@Q>_?#XcSbYOMo|=8k1Pc>iK6A-Lc5!9T13%G zviU>_W&Hxl#cX7pP9UWgmA?b1LgE83zYOgurcri*kr*4>-U3AN(PzO?V2oi4fneqi z8&vtHbPO8>M%pyU;u}e@q_Fs|6!1$8V|HXh6u z_8CLMSGEr2LV0w@F;IIqd==C_qdh*(-m3Dp>?>jc)3FoC+)e<{G2z|8l6`(Y-<};! zn{b(5KIb=~fZuSkf_~$K@U~tG0p&3Ke?uuHpT<`d2w6RrYGkIwdEQ-%aZ5*?GE)ZD zcfxy-RY@T5{9AZ0CZbSLOeAJf!n?=RhCEZF(UZd4Mhx_k7+f0Ob|Rn>5hr7~e!cSg zfnLPSN~TWIl$$gX6DDS@!o<^~X*5C?QB@+i2TkGgc>7~g+p+0rY8>qlAt;s`qv?b( zA-9Eu_fm<|mK$T!v}{lfvg*RK+=!>S4<@_^i73PoY3z;}h>&fvPOPxD$jS@6!=I8R zsje6yfL6k~Qg}zH5;|jS8nVYekDS2DJ;?Tsvnc~O*UU$mCEvmqKc?^^-;)5!(e7ys z^&;RsRph12;b=N0yf1w#Q~^Y@72cQ0BE+hTpyviqdF2$r)oaY?=>vYEVvj(OOh$oCAXQA&Z68`!YEL2mo;B7@ zLU^k*-c}wItLpGWT2}`XWpyw+C14orCE;DKvGXbnX=vr%kTwKH8Zhq^n%BIIS03C3T7Tz~|*!(b#so_jwcEm!zMWSIQvzYl$4O{3l5`7w4ZEuMx zMc?Wb-YJ#&wkYB3nN^UThZm6% zruGuXA!CH!V8JWJx(Utu9?v5{D0{as40F|8OqL{Y^d8xpJi7)c;-caP@+4U zd<}lejPyykMy68o7E=;rmcn6GnGz+-^Bd+YBBaxntw%%NlQAN_%Zwwx2-#gHMAfjger7@M!)@!m1c65jLhX>8vF_&bi zlgc(C;eo;azP8?;p(CPn+(pFI*TJwVUD1lt30HnkXK&aT2oLu3_JsR7j@a6W()a>Y zD6Xf!Q0nbBQ|JBC6TK z10CVMA)}|SV<6l%7#5|;ImDek`yE+V&&h7HWzmGFo+wSZsP^~w^$hh7nD&8%a%tL? z+ZjIC16`H*Mf!Vt&_${x+6Q{}b`SN12VstxbK;<)Zmt;@my+3WU|@jNwRCb*AD=^Q z*9<)$>1{ibC4AOJ-qGJT*bg(a=mv+{hR~EJTqH2}{zEo_Wf7wEq>IMX(G;eZe3oUM za?#m(sa9(bcjK}}3tJbOD1E7mx(^m;bM*8@4!G>^WiC2t-j0Zu=Vs-xzE|YZ$cxRs z8m`IBZa**p>+jjy*FOOB?8a5u-QSC=>~t=nt*>3ED81H2G}s#sM_l!N<(xdFiBrUN zZi=C{zRva|j#0nLm3g4AZD=Um*J-FS?8>~_Mbq8Wjwk-;V@Jem@@99n4Gs;qz`AMI zqV%;cqK<){A=kJ$G|<*J2n?@}>s@4nM+S$&`;E3kZAbR^cfzP%=gL$@<>bA7P97{# zR#jRgE~Gcip%@tIFb=itgXA~P$ukRgto2PU5;L>?z|asZ%rTrdyJ%$hnH1(WS?OC` z`Ld03^3S;P4-8@)?i&gZbhUMabLigcqU-JH?C9+u3|o6~r8i_}_D90zJYn5R%h|;$$NY@)a815z6+ZQD3>TTOQNV0bAM!BQ>B9J)&XbDOSgy7$jZXHN{=!}UG$lXr&IJi<+W z@BHM}w8Pf;zWHfw(N^oN4m&3OxePDh{TdJb`!2FaXFfdo`z?(fkI6ql?e?RVV zmX04f8=)H1AIwW8?_sL<2QkBzUH{?vDKSE|wPUGY`q2C|s^4wH{K)*2?&>}~KUrsZ ze?RYo&Ykw7^AqEm%ccHUUg{1`5F%{@`#8^bI@2lS<7a1cde&iki#{|aHQ zs(j%Eh;dcvi!XrPRr;6mvRhY|ywunt16Y5G(!X1fn70nYoI-thK}sx%)M5+kIhQVv zFUZs#ZtEQA@5ge}xn#eRpM#2+-6l%^etw!>%+k5+@5VGzl>S3rLJXWk13j2thLu%t zi{Yy-N^_>$(T{1oT=%Ql{MTG0a7ubFvgjo)>f10^9SHAl!)3}z!?#?N zdwcuav1P;QwGqJ>geHQle{@j{Vs6B}3$%?~`m)mxV66If9-166-*J)1>bAFa?Bfm) z7F9!SgSdTu*F}+&Y4r6E^>krjq?SVeP2Say2E~f7`@oRe-*`%qM#yc?rc{@h`&i!#$_=z^ ziq3xahS_%};rAUvX9AZc>M4i9E^N@~Y#VAbMf|`autj7M{4kpUtE3L}2FFWN!jI-B z2p=|So_1)4y2Ate+j?p5ShwQJGD)6sNT?}xSzOH{pU{{7vqNG^G21`8RemhVHuPZ| zx9k=^fZuSK$#-!Jw1j(@|GL54*TuOIM&^{<0xf&b_kleRPl6E?Fp&|9D#=8a^Y}F2 z6x^}JqH4;d#1cL!t38i9wClOaip}`w@Ng=2TrKxiNu}Hu!oL;p+Ri* zX7Hp4=cna3wrIBo&&Ppd0TWH&MhM%a;YIIjP2@Tt9|kg{4QLG^?NWXn)*8gdkV&uw z1mDR=&|(to0Ksqb5Y%*<1RWsA6)!dqqwf4@OSa%!{w=;%+k((HJl#QqzEay#gU%WiJY4NKxF@w?yMKc=nMSrTZ`cqBDhfQZG85r}ob*;+vRQ(0|D8Fmf<1l;6 zLC1D=qT|S4=~}gnC0edk3OIMysw=@<XIj&VdM8i3*RfHVZDzd?~in4x>o%brIb95uSp5lp*D4~iU8{(JHqwzwxmFRAdUeu)3u5K8b!HQQ6<~8>TAdetfYG0 zaW5$z_x2u3=g5<)&SUats(**4M3Q#RYa8Au2r%Fa$Ktx z;mPvCu2tmPW4cMepCRqJ6v}t!xK@!UlI>a*f@Hcz*sfK)2##6^h}-jtx(n;e-7i74{@2;Zw}(D_^7PvasdO5MDQe2b8^iWLiI(SW-V z2sy%Dj)b&6m^w$?V-^exfIpbyTJ;OtwaPR@x>iv(%$%-OOuAgFI?T2n@yLT1DnFZr3UzvRtcp!?{^0sa&hdU<9{0 zu2nxn{yoxNM)~$sX}qn#wW<|Aq;+*LQC0`DQ(Uf9>^zril>tWO>O$8lLIf?>Dk|x7 zT&v_I4$Gi8iS*}(0N?Dd`6(Pv7T&oB=u2sC7!?lV(pFoCbUDCB`3|A3aIoq{L z&I~xX!12d%t>Wbe^>SRRC?Jr>wTgGGe6CfjB+Mbpwd$4Vc$kFgT6GL69%a+J{F>hE zVe`W{a$T#4hMDBLRuO$V+qLRA6ulmm%5trG4F{1qu2s}gc7C>N6@}(=ts*|ZYZY_y zxmFRM-?fT4*{)So2Ch|{J+lh3^Wa)VnA%Giu2qEJZo!so)fa$J_9k7c2oiQ&tNsxf zxK{DXV^Ru(YZVQEsrNuXCBw87G!0)R?#?1=(zee$ip<*aielvtC*GLTE(U<%XY1jG%nXF zNs`BR%5<$_v1fIyBGEayRu!T17jUg|vgdWJk|g8eWr|J-=&JjvCoDRNL9tx}?o@t#SmYJf(^AgyuRo z_gvR1hkbt6Du*VoYgNANIj&U>(Soj34p|=8DkoDJmD{x{HxHJW<64zV;dZUc&CBCj z<&ezpTIJA4o5^vBdW*X!=pvVsf5w%+uxpi5P9E2)tjs*FRZhP3M9Q)Kn_Mbbxwr=M zxK_=T;?OC_AL&}P5Sh!hY9TVy-AKAtEkvhEm9A9_k-1!}79ulCm9A9_(Wz3UYt=$z zF4wAs$jnmV4E3G`dqR~8viB}X=5noaNQ(ZZolJN zl~10!%1vtdl=QB=^6bZI_QS%v^U~SR=WM$7&r6rrujQWk$!-4%*TeC9=O?#)K&*$& z_svghi?(R*pP$y2t2{*>n4i*?swh7&KP3qq*Q$IS#fCLs4_^U}zf31cagFW*PNuPn?~{F3RG0^z1xYu2pBP42B5Dwd$xK^E2 z(K$j~!^UHOfetP|q|cq5?JseyI%^f?73QkS7hZr)t}1=;1+cqH|59G|d0ngW)z~7I zBb>Rq`SMxB&f{9Okof$rRe3pbT&w1#$#t#DM~Hzlk871fIj?J#Lo%Ohl|zx=waUrQ z>ssYx&+l60&{$Jd^ip2eDu;4D*D8l%e%GqGG;>_591?je$?=||Yn4NhlR3w=%Aw5X zTIJ-P&9y2oWsYl=LvvQwDoL8{IF;oO^}S#oiu|rsHlZ_t%M$fe9#L7IQ$KJBY!O)m zKg=e`=USDegqy(ST4mGB?^{>;#g8gu0>f$j3Ws9HQz^&S!;#)qm z`ZE&pIfqxK_=RllZf;OV`>4ZSwI#WZC)%yU=i%Ao7~G4#K_>j2e_=?S`@@_ed^TzW z1;5e;Hqz-yY-%@ir;sB;C-B8jSs*lxAAYnl;YY!RVtXN;O1yZG)7cJkqT^9Ag)>Ft z(|_Xwog!w}@o6{zj$psvW7>zMfzV2F$+TO43625;N{=9yX&3~c<2cCRc|w;8yp=~C zJ@jY5MLzff;Prp%5GT_ZUi+dkoXe?RE@No?+q$6T9%lIXTw`cNcjuD*w;02dFB-#N zXbeq%TVqJ(j0`*Q+&*VyXo4~1lKr&D9S$C=!?`dxfM4PMW+z7${v{_z@*ZQjriJjwk6tGP5=)|IoQh}gU zz33DVi!8MLdy8%)L9wssj>ZO_NMs&y_%jfB3ybdl5`N+8#`6@5-d}G6!=mUOlF-jp zIrkRbNj(TF=iZ`wZ%2NiC@BE?w@8-Cs-k44kfQtEh>S8HT8Ob9Y_g)iBiSMp$rDR) z)+)pqGPt7|QwZyv&;kO5R(}`Q(vQ55W+HpIxPdLmY~|71dV`g%;9VawvsITA@Bglq zZz2YsB?1n9@o}8~1+Ba_X0MsBFZf<606#i;!lVBfvvr@;YDRX8|1O=?SAFFF;BEp| z9sOUU_q6US!qB%knVFF1qMj{imevyG)0V{WiU7O=L6p{A2N7l3(&Oo5iZA3S zJq7>y;QzWKwvS#UKhq|%Jodr&+qTLD3`)uwNeA|gU^RTqu;cT_A zEbcoXe#&7m8+EHgy-lKIGYmEwr-bIka9Dv)Zd0%^SBVwJO%V-_i0ukz$%tTa)(Zh+ z^9Tvb9$7IvB}(ynRI78FW~ajOcwA_&1>3DQD{CFJzr+gJX~xI|P7Q_)i_#`XLSsvI zW*EZ04M9)a!hQnF5arPf-ywt3=1QBvyw5bQRtt?*WB+N3@wFVEWw+xCT&7XCxOlcJ zq{Yz&!o4=fYL&@hN0e@JsoCIUfb;!e&}PX+Zne3ZOROgB_&OgA&# zTKNFeEllsJ{3_|UG2LDHYNoeyIEqwGk!AMeQ7R?Fgeq z9qfUu2%|-v>;^;_QRH!as^BK+I=p$&UJ7)hRD{u@Zi;f_WrWe99)-?{Fj{npLR%3= zi}n#-j|Wyb73c7fc%m?%UsK$?7<+TV6VUH2K2(MsxZAXVes6ItlIM5hV9Z!b==T+W z9WRs)i1T}6<58T!s^4FHEsn$wRGohqZ|W8L1H~zVw-Ia<`Ue#FAi*Y~e^7ys5o{Lv zhZOh(!4{!EsK93kZWH>475LmnfZK)skOGB9c!$tGqTqmpaeU;%3a*myPN9EP!3`2_ zglZpCh&>7c7^LK*dKD;GFakJCk zU;I(F5fC^QTcPezsL-EfU)Mw$yAwETPd{D!S;kA&M4A+Qt%Q9wk!A(IQo@0nNQ;86 zlW=)WWSfFtCE==?$aV$4TEd~4js#wWbt2Oxk4e>EQ~VlqY(vfd6CG)E;cF$>QZpDE z???;%`r;Ynwi4_F_&Nz*KrjsO^%C4gunXWDBzO_Qy#U`R!94^A0lrCs?KNSu;5W;X zI%_&pX#TfI-MRsw>CZ?Y0szhaRtX#i&@A*DBybb}`us)-OaMTK-z0%#%|P^o(BCG3 z6Ey=P0NyTv(=`J)rd)rA1g@_c7zS{&1kTh9q?1B_rvz?B4uD%Ea2s;sLVuS8?tuUR zw@To_nt@iKzgwmssTqJly+@`Ws~Mm%y;lN{13+zVlfV-IP@CH&@FW1#=6w=)1^|rb z4hcL90ETm?1fHuIh(npXB=G#^UrF=OHXf9x{tv{)agH#ry3Z6pEw8$QEh>loo5D>& z|Ey%Zt#C^x59hbhk4f}BgIbEs5l+63Q%zH%Tg{`Hd z$@m4C`B+Y-&HF`}jhLHJt?CSY;7Tml@x$!r5dV)1IOiV6?)^uhO{S1i7Uqfenq zU#HSXhQea;8+acpJk&qXDHgwxECsa9!cK*G6Gax#mhCg=3wt96`+GqBP9H{V-S<&s z))pS%Aq|V)OLE=!I8b%2gXf>n0uM!S)%kJiWo$f=isNMNz{CG>35RJF7a#&3+ptfF zXZ$L9Km;DC=oI2v|HxI0Zot$u@CoYtoL`+-j~TfLJj%P;^Y!Z98u;Y5ak~{7Km(#TM&%0mpL26?y)aC|d>hk6;>x9sgrRQA*YSqX_WN1JvZIlSv zL<;fQn?X@*Z-s)0=hySKM+{9Y}-;8gL1$f31Y01{DZ6Hg=LuGrpvK3Wv+FSe{jP)L0w^=Z}w7WXVKX~d}fX#5z;7ebH3kHx3Hx0f_79n=L3|HiHpbE+_ zYO7Ys+~7eme?(RRvs%qlk&k+VG0%I-h1fZv1z+U}ti)ydWbiefFRZ}4B`Xpv_*##= zRBEy!!GhO&I5hfdvLeBPuk&Qqpk_7dV1E0M?cnP@G^pB|oI|#QZ}3q6NR2BJEciwb z2b06V;gId%n>-sK@n}s}Bv|mx9&YR;iFF-t9ej&KpQy=>1Ph*#=+n^3I%GTeR?n*- z_Igyxi3AJY;JFFNGtkm?$ae5XspCB?%M}S0yh#duK%(6`yiMXCCO-R+?cm#G&ZnrI z`;hJ6J0$*##AhF}9lTlQe6_|tWIOmysm!;<1?aZ-dY+TLMavr#!P`A|LVNU{71GeQw0I&WHaR0M4*4o zkYf{3UIT;2kT5Ozt02#Qn?o?+`66VTN2ALBHiuwJa_upVCMJSu&*yQ6=&r#9V7<*D zI3tN*DfZhOg0r5dA(@7vLXLx{JRAs*S_qDZFO_T)HS%o^!Iwz_n2jBBjN8CZAp|C4 zh8zb^OODeL!Gq(2*Gfyj9_@;dG869$wbMvxU~B z-sTYefal*(PI=K5R7xJQAAHF3gVh+ZBnHJi?D-`K5OS>hc)80f`t!IzU01Z+?J}?E zJCU{H3S0y~%cdbpEnzW7A`LGvzTV!EgA)E7Ir4_K0y%Qn!5GII+(rwQ!+#e^Mg&TXTFvv;2-pJI*-x{3?J}oN@5?gjAey@DF#Ra;`Yz;2+6p#Tf_x z#6hY7jjvwe5EOC>(#kHyD;$Ca8pkY{irVc97He!GSc;4@4th1V28=|-83%nDYYq!R zoN=&JW6`h<#2E+6G*$zafH>peA~{=v4ahj-U_dJd*UQl1vj3N8Y@};oo)8k0LSP+M zoN;iaWIh9%Qm=3bs=3!qHP$N}f~z%deBZ2;#I!BAM*A{a^EPSlu+d8G9^7T_kt2qT zGY(d19Nr!jJC5Opv`*&*iLyGFol<1J!Xda`W9MCHzQQ3G(pJNsXtj8SLvXW%2+BC) z;1;R157#YU;Sj9Vc%cVi8MH~=_ceT9XurZC*r|<5Su)Nz7?u!Z$vER+mjsJ(C%`Kl zf_pVio)BluAKnZs>*Br($6N^`bd@lNTL~j{l`sb|39l3->>mza5=JyCZ$cbNESU7) zw%~HHj$?srCa6z5wsbHU=ss@ml(0S;b}%F}-t6r@qd(Xz?~J?h9N!;oDflgHraGRE zP9`VthU-)cuOnJf$*KKrV}D~)YnuoJ^u0yg9jWO}%nH4`D9ov7O*hV%5_(S&C#F7e zk)qWvDGGBR+IfS(%5mO#OK!!K{u?0Rn!_Ev zS|0o&unH&N3{bwDS6Fox%}PmQN4S=kOOp8_T+3In#OgfRu9pXtuO^Wz!qqsue?MOt zfFqG{czkmcG6VWma>qpOWMHLxD3KZ!`Z2k`AZl=GR%RxxaFY_}sTqonE5uYWTci+v zBIwj<2^7_YQ>jF%KZ(~XW7j1iS&B`hdVPwXlzSCEg&d4c$`!cKua>lBjU|+pl7L>r zl|jGBmzI11iF4R8k}}vBB-@MxR#^Kl$0bL(0*(FA^f95&O5ED><(84P?#GVG3D@qL z3w^SfCK0%8%Rnq0OC67mVt3(GF|Fb@ObBaVJ4qw`LmCa~5KixX9WM z)W1~xH1{HkB3zm1zwv(^hFqYn6JpmquX@mjmtKm&$;_Vfst0|DZ$9$BB7lQ%aaRG*$hG&deuPs}BnHy&9}&LMWkBkNbs$<7lys;693 zbK;Tpv@7?V;*s^tIdSB~BkMCRuCvA?>&NF%+ciVa=f3JepLLPvk4M%|xJXo3ktN8E zN7hfeXcmY^)=#MzgD%42=6$fc1N8$((c zkE~yln>|lFvVJ<3FuR5_9$CNEMU)edtiN(jp3=mQMAENwQ{==W>#uTU&J&NUzuHAJ zHy&AkP2TM6cx3&xE~5G4k@f3cWV!Lk`s-Yo%BbvkWc~GX@^a#l^*79+u;Y>SH_pk+ zjYrnsZ^cD%9v7FT|rS3T%wT=@&cBkON<(dEV?>o;U)=EfuIH@fnz zFb>D|Z_1O4%Of`)S%2GtbXGjF{`LjQtaxPo9Sf4#@yPnk3({Hf$oe}MB(vg?^;;Gs zv*VHVcP&U~#UtytE=Xp@BkS*8kj#!p*59)rofVI)zjr}0D;`3dh0cse*6++qr>=6daKGH)R>-Wr0?!+}ZL+`!wliPulmL~VjPiu>|Xz!n&)|M;7EA zNdhxKSO4JrWOxqdyy`*!(AfxOJhJ{^UNU(PQ@wA+BkLcYpAsXKj7QcVnx7^+9$Ej$ z{FLtMK0H6!oOopYqw^EbjYrl$mX|tzgs>B1sek!6JK(`V&B$fEZVmzW4&zU8R31FS`|Doc*c?{qGhe=B>kg z)r0=!1u3y4%JZrR{qY5v^28(SU&+tmjz`x2etw#)cx3$_@)Ba;%#BCZzv`mQACIhm z%|((o9$Ejoiy}`vvi=QM{@i$E{Rvn0Jn_i-H(fN=L>9d?Hy&C4mWwiPJhJ|eE{b{L zk@auqp~;R%*1zK-k+-m%kYk~L*F}+&nH`U;|C5VyPCT;yq$_v9cx3&1`6=D;$oltP zGz-Tg>rW}t`QwrG?*-)sS~f+Vcx3(i4xuxFbH^j=PdOC!)Xg1ktpC6vutj7M{4krq z9d0b$8T22`PhiC(>rXp0^TZ?T&p0I1G*3LT{?87{0`bWDk0qJh4*z_!xy6a61@v9{ zmIYsf$J+gacu5W4Nz&8T)gL~5NUYWLKdk*_3%24%XOS68r4caGgV)DPhf4jAYo!+o zGWSQXN~FwuxROYGA@T8P7yeHY?*qOa;Q^!YxE!Vn*PkW24Cu&YG&7b+P4!?$`@bYM zP?J8@G1zH~78R^PaLeoMU5X_z6B3z`nap15^hHbf1pz!fwo355QGu@ps8pfp@E5tmkW=@X|!} z&YVF}zG~5<6gk}+n;y?hh*i35dH-Z`Fg7xSSFxY$jHO3X@nivMt&+=8u)qT4_xo$7X>0lw+38T*H9h|f~(Xe{yqdOSC zvU=G=$m}Rwz5Lzy^|O~oV(D}u)s}*5dj^joW>PV+dIh^(RI;~LuVmUId@$D-t!Qe2tM#$LUl7p)>69R3iE zE}wqjQN_WYfuRF ztU@AaK3yk#p>d$Ervq^mc zhB0F8Pqk9{5U?mm-rApO8zC-?_^Od;aztFORcu+)fo{fgxlD}j@E%KuiaHvU@LMr9 z74;m`8tM~i96l>5wpM|mSF4{*%;L#%MFX7#PiXa!mlhR`tj1|=1q>u3Dj3(W!z`UDiXCpg zR`L-Kwnw3wb{$w=m(3Q%6(K5i&S4`SY}c~1N5S$~Hru4MnTiYCd{RxBVKM#+Ouu&+ zlem18=TybTS&ViD82tq(vGxL7d-$03i`tfK;Qi{hDOc=qOKED#PiDzH4SBC|WXdj# ziHdf&jO_{w7J7SV9|8F%92SPAjT+PH=2Ow(W^8P7XM$gL)33n$dxt-sHcU(Dbn~`a zc(A>J#csY3HinN``_b5#F+LMbjT&}4;kMzH(6}=X4W#i(*G@pvD;#N4Q_&x;5pqSDk5$-BNkdIJZ_&&}g5o;^$=?ZrNO;Ycf>AbX-^aFd)|M<)O2rjzD5OTPotep>Zn4!}8r4AI%c1S|cy1CHu3G`z1&Abi$ZQA8#}o zjC9M4InH1#H}7xJEa|Na5nJ-twId=9A9ssj>}qNmj%P4ZO(xhJ!&!2r1!54(BC_Nq zAZuo>Jo7pjNynS75)~u)<++J0d7p)>FWK_CM&Xr)w`1h*wHU-&leeZF3y?y%7Q_@z zO#nr~n=vDmQ)*5K<&=68CdtI=K2A=n)eI8xrjjz~L9`~&Riav2#aLo;6qnUxViq&s z%E3#>;m(*zCYfD*JN%qdMrvkyn$h8vN4efCbOQC)9i%5Df?L@ESYgMEA<+=n z`X7+%pB%wmCD6!_dtnFlG&88jSNS##i<*`VNC!m0he0jPBo|*&f19KU6d!G+%tjBcXdIz`=C{zODZR$egk`@Rx;{0(9Lu}M*RkQ zm@b!5zky4bu98u|fqhJeWYlk^&8mFbgPW|4fHX+M@Iby`kC&QQNMu*(-9f< z8@QC|!!qhOFu?Rt8TA_&WO_nI{RW1ZPRfYhz(J-@$cWy+A*N5uXyCwMrmvULz=0!7 zpOKNify>Y@+S}NE(a23-k z*gJ5H>42*G6w~GY*_=vDv+OGWY)%CdM2AGdqbQgvSp{1frC4|!G?H;1L*h(9AoGSE z+C1hHf#YY8lxghw1ZD{xMal4=4V<_Q02(b8J0{_igrBcJY>Z8zNl#J92Ce>t0$)n7 z6-!zLzKq}=tv)(sB&S5+-1gL4v~|n9Q&dS@<=waIJo7)PTb&#-G4x z5wt6Em&jVw&)|=Q#4F&bH zW^=una4TT5z1~824`8#w&O8JDZop29y_F<~C5hDkBZ!I?y<49*d${604kb{PgP znyA7;&&nklgAgoqY-%T5vVTr>_-#xt`Z-^&MzVkt5*>v{IFQu_|X#8t2bhL%8g<*;1{3oF!Dfi^&W8 z2z0OB&Ezis7?Kw;d69n{$%~oXOD-h`(vi~HVW+YkKzP}>UNghjdY`^?qE8C zbd#v=Wco1D&7wNY^iia@i|Q_>Cy?GDs`oOT^rtYpt?p*}gg=F&8>)MlK8-#^`VywE z_or}hL-jtU&-hbm^ldNGHv^CKex`2&J}#>Jn7#+RNcS`Spg+|rsv}H3;!o`q)t55) zm_OAB?FX2C9BF7j$n+CPL;E47pF|qkA7J_!q+3MwL8hNYdYh;|#PoB@>JBsgeEk^K z?rgdvG;E>OA6MXI?08X7f1H)OoTRrE){hR4i0Uf{+*4RTjGIFBl>{CHFb3cy1Rg1@ zk1@v}@E8E*93}90VLjGL%8a8#JW*Ib!ge1ffMZKb`1>)GD~+>RbmL0rQA57!JDvsB zmyQGC28O7oFR!Mi~9-SPodq2jW_W%Qf!C$sy{u2 z-wt2(XD-68pPQj$xKuwYpZqCM9yn6{SU*O)LeUfinU7@2IF>y#({b!$8d!=|f8GFr z%;Al!`U||LD1kCUr}`0EokB32&zMjT_o_cZZ4o#Qk?MdaE8|gS$mn(Zu483=l3Bsd zGU&2a6yH?+ot>x~pO~PwkwMh!boCE^KY)4#tN-~Reo@b#RN@z{#8zNKR{x9Hj^@E} z)juUHI?Ae_?Exi5R?KWst)D+9>j5xZdC#t{qU1~{CMG9AcpX7nge?f6UHEdENX{m_SV?QS?c%3M6x~5vw zXmv&G0~r}>NPCTG4AZ+1NFJSq z3NVPy`;jGTK(4N>l=fj(rSWahsX8sg9s^?CN|35k$7G64gq1&a)_p8jPD$&Ls1myv zCdYDyhf}fRqWWoV1Mn7Bo)B35jKo!tYBGb)A2}w<*T3^t&|&m7FxsuZMHWFw4Z-W* z#TG;hQ}(HtSbr-wBJhM;a>Iz%zZ(ZQiA${e4=@{a-kJiqDa}|nr9e?&L!jw^5c_by zwn)W>CHI3hAnJjX`=%R~lIEF0BA}yem<`L=F3&2Q)ObUX3O^??O34k&`7GVXnB>n; z8LM0>vx1m_?&C$iwhCnD-Es%M*KTG~R<49uvnW`a1*hSeQ``g;=e=hf*j}vtCh_zq zBhIfR6WgPg7sV;eUBvm-lu3ydQ@81j?(2cuxKxcT$l^Ao*tm?auX2=m z^5la+x^FM% ztA7Ul;Z0>1UV-k7^QF0Blg?vI0F8=Gi}}o}&_5wI1$c0Z&kv*7w1mlkUmdxKjRi!@ zZ(2%RIVLYK7kL?MT1F$O!WbZ%X_MTb3i-!)4*#ZA^iyc?;}OtgY+7tu%@L@TpxCsA zYBu}%@S^}SCd(al5Kgx=kd-h^eRTfiYlRGzjQk(%_ zkk6|{IriZ3!g?;@%`+)CtlQG4@LnxgJHa0kUHs>CPQ+3bAES?r3!&j-twv(h~6N(ksE1Xn4xG9Ui z)yfFtbje#le-}Qo9fPcySP`AcB(QBh8N;r;*u--wT?#h2bI};u55WCnOM+No^YM5} zhi`|8XPNpD%zg23mAR6Zy@_X3IxINUGSYQb1B z8nvxTvl2=k50cE0cO3GRIHA2Aa_+Zf@e+5$m=frVkRyQ_xfFT|0)Ar)v0ZxR=(20B zB}X zPX2aH+OOhq$phE8nWfqtNLwe3o@_oGBlSWrpP8wUJaDM}5JkXwxNGWj5}ZLxRIXWs?>` zLI5At!yNiW*C{w8V7%U!C1ab!Qs)+n97}+UmPvh z`a;|8!f%H!wBybA^#Ltt&_yLzV(FxHjbijlB~FS^8#Hfhbg8n#%%b|g0_(EX;J~zow?i_^TXLf);Ync3 zGGX1<3*te{>DB&0RjBI&$Q|;9`m`&N@bU3_B9joIetE;4kaJ9ROmZl)4|jF3L=KLj z9_Hg!FLHhqx`bIc1vr_&c8HW98Trscg!ak9LbN3l2JdX4UU^!GcAydEm222mko#Vk zFH46JaoQI;{8IyMTNOIydkI>IJ2kQ6Xx&M9efaUH#h7gop(*w)CRp5(nwb)z=~bvJ zp0yw=QIBLfmhPAVh|uK}2j{v;PHy3Y7F0FrO5eeXoNfuYW30M(fFi%E;ov&*jSr~Mmc~ytZn1mBor$;ibbKejgynm7y+MW z8)r13@#O#xdsv2?(u5|6xT2swEl({Fq2!m)AV&-9(dAN4WeVxc8tCf6rW8Iy{4Is` z)`Uu7XE#FT!=UD=M^iXl5H@>iJ8)QyPG=HPMfGy_9cG3T*pS4`OCev;1u{$yW$)S8 zYlwXw0{I-zB0Wu{D5{^CJ~o}0wdWPeFs|!GrmqMbnJJvxV2t5OzX-jC%@=a8%o3s3 z5?fnTKQgP1=@y~avyU5!u(czvI5h7YX|b(E^_k2`S)DiWq2E!Q*T%g$cAGTqYZS}| zm+*fnm`yCd=;MU`9W>SkNazu+MVq#dTMH8zsL%);ab6H3h8@INfHw~b)xi_fxOK(?Hj2Y-!}xPtRz5&Eu6ObbzJ zHcDQ6g!U9zC4-vOW8yo7T^bSkCl}v#g~a4sD;UKp4j)yTnxQ9W(i0-|q>G`2D9nen zCXnv7$$ySk7UfB7ScksnqHYET_gUs@BOpc>D*2*3g>@D;VM5<`(PI)Wu@=ueK>u!s zC!Wq~-KW60&u+-(tXxQtbDHmg`)Nwhk5NO%nFzzL2tDm8yRkVdGaPBP4vQXeHqau+ zC17sF$PzA$!OsI9)owu)6I{(Nj!eNSmI^Op+zq8G6^3@4u@!p8UGBD=?C`whY41ll zpR&u!DF&5;Ghxg)7E4XTXFT*{cOj^pE7Mgu)l6axgEu}-CBzDKHDf^xf68&*>VM)E zxGg8!t+mi1kaf8&kBY*B8YXHE5%zvn=vlYSoq0&mk-TWN_d(h{mPD@NXv_vL@t?ay z?6mPT>F=v?_9P$l%QE|$jaWAPI+Nh3OjPBJiz(IZ=1GLAJGKC(f?3N;S= zn~SZ5C{kVssy2rb{%3N`_;(lWc7-H0Mj?@~smn>rf#QF=sTC5`(!SmW>f0R-9KdKb zqCFh{!o}U#I+p@#S`OIS&miWPmMC*AEeCJ2FKvN;bPL>>ha@~afQ6X0V*;oCIOHmudjri&(X37%Rpz`Yn@BN_IVwoy~UC!u7u}t9!Y+;q^5>^M3nU%$a%_WRg*Ixuqw?rL`Ir;8kdVX>#kE_F#$}l=iosiiwrD)z zJ)lL$QryrC)k?TryOOd(_0$U+*3;ZOL8F|2;Op>N#u9=&b4y(L3Q4)sqU@Bf4!Irq z4_JiDI3fsm`0@1l&>o9&n?$g!|G}c<#w2T``+m*}@{2c9bE2#JSZ&?+2cTrY6K@h~ z;FkMfx{s4U-NysN*2pdJHNKlM9a-b!di3;zc(~4(Jkm*v`!Y`2B;pJZvWLEbYRpl1 z^OnLNp)T#D8Xd&jK4PN>u*T}-Y;kj>=FieKMd~VKh?g4G*au z^1inHVc{`RilBfHPEk=%p$WOji%fD?tfnX?P6p~7Y&7=wALtu0hIo9%pztzBHjV5= zA3=tb_Vk8@-;`v)K060`aLQn0Al%h+7;GhGmej)NI?&sTyFOTPxXO?bKHL$G3?WW* zP?XIPA?v+}XjFodakM>D+sm-BXTMi9#++y2g8hA{>u&>imBXY>srDpD*b0-a-o z2L^D~Ue`eXeo6(@KOk0EnUVg%p2K;CQYlgF5>A)>p#f1g;(6i#J7C@Po=_Z^IgN~Su)?FaTkk=`z`j_}}-z7DBx-$7AD zM9#QVEs0RQ&i+Az7GNA|8$ht{Ua{WFiNFkuec>ZwgNczXfj17b;KS&9^Q0efzQuu- z4iEGpR&c0)U${?fB%V#kfLIFJL01C=+s8YxjrG|zPDFqHl7Z;OaJB9U;R>WS(a2!~y`t;9j6Fz(3>Ohaj= z8<|F=BhyVLzHe}FFdPxhCW!O?(T^=Av=<@Monjjyv^NdhHXLc~+nK|wsuK~tY(ufb zZ zhqJZKn%u3dnTn3Xv359~9zmqFsNJD)hZZs4n9@%%N?g>oN)+O~iHb8myLP8U1#0j# z2{FBVkS8DJ)m|veDTh$$BUjt5m9}E%riNSRqP9b$lUt|;t9g~(sm(&IhMF>dLqWy0W-BaW860E&K`x9`_)J&j?GuZX3eTmky4f{eh(PZ3e;G^=* z56>x-YT&3u{n`}WBx++?!3;J?wy4OGDX1m)Uuv(?YJo>kd@>!I8I=#u5_sTEA3RYz zDXUeLlPPOFC9^`>mN*O`W(@OzTkW(&HfUSa&W&8Yj^Q13qV{SnbsXJ7a;wKh?Tq$Z z5WT}Q{h5#v#q3Zu(K5q|M}Uxl2<%Dae!z|KpxijueJ=-A_q{i0va{LcgBU9+`F%i? zd=+2($hkuS=)VPE-T%UuOCUjH{Q`IO5=L;d-6caYuyk;g*kx!fQ;gJ#trxVzpsi9# zb#(ub(*RX|H?8yA<8BVYL@>b@iKm|EK$Ajbr}?z=JrbL<{mxuWh#4<^}-jV{Gnn8Athv(We# z_$;HA;!3sh9gbnui|uACeMQ~(<}f$zm_tTU&5*DYA0=v>>*~7i&t=ZLx;|#}q0yV5 zk25RAekz<`Ihm^uu#*Z0A{|Cgmtj8A+uF{Vd3DdB_%tKx)9nn*I^JM38Y4!0jK}C> zptu3z^O2-&lFf<)x9Xk)YAaqe?v7##UX53k7;Su5?__*h9#g`Mo{mX87wN+GPa<_v zG)~Dt`CT$+e>9bzz~*OD+=c8**yxDIkB0>pM>?>a#-3KYdgj!$&F^sJ=A!MMc4fe>R(>RvIC0Wa?uP8VLAY30S$}Y4MFveXvN9iAh31`+F%Kp+mP`z04z zaY&osm_Nh^dZMXL9rh!y1hm%3L@F^&->oL|?7G~HZsp(D)UeD|pu-pD6Eo5D>ioH| z>kRJu*ph7eX?}|RGjL26O@l#4dI#PK7Mt83LnO~=2kzf#(e!y&wzQM|(P`Y}Ahv$F zn{jf|y5gH2aAlxPyJM4>LW!o56%PG?@=GzVPSv|8Y{o@$2oGcAr3NP((e#8Xrwv=; zLwMioFg!odkGO+2jll|F9`;cTq&(dfI-H-Bwoa@Dbaa;Klgz9BgM| zMt0#ZTzFo*6b|oh*fzqnn~tq=WSKdlDX`j&oKlVl&|D2kkGpaqg@?TGHe@S(aE-&= zh1a$X%=};W-aJ08qskYrdt1wGbzAPXTUN`m9ocbW$FaOfmMklAl$O-86l=3u@)DM| zmevx>l2A+Dk`O}@vXXsI$exgd1VRYw1Of~U!w?`W3EK=4;Kw}PV;&E9KmrVt-}jul z_g39rmUf*1n0k z@$Tuq6s(5MemmYjt#Q79Akmh5qI}3F`PSvS#uxOL^^RYS8b^~ z3UsJ$L)0$zh^bMF+K`fwz_Fg%u#zJQ?i@tz5+!7bi(aZJoIXL+MwHa)f4k76u(mI1 z%apElw9h8Q-zsXC<&xKk+VWiTT2UKiIiJOqRO5-Ltw>W*NqKAx1@8e&c9mD&PTOViu%~&&PK}G&Dy8U|1ox9{ zy0xo4;$Ex`W1tnaYm}Hz4ivSgXGm=Os$I)+`SiUBWX~R`YtPW0y*JS!dt&%Gh}ttV zG?*hek=A)s9aG@K8cw0a@EujuuFs`x<8{;8vpl+1FoLwAC5qY&9(glP(`uPJCTh?2 zh^b(uD^yz4Zq!r>d{LhmMlU$X&IPsAS-Mty;I7>y#b_BVt)uC^)00R})Naa@3~|l#b90z|)i!2nho+mSQElgV75(UNS$?ip-ZGvVKE#ThUPb5N5I*(Q zp68Xy@!Yw2lULb^BQ`my^S$!KFb12+=0UW%m{+rls5&@GbB2Q2?%<@ikXmwJCa4$G z3bNIUX+w>90dX&&g(wERh&C^R3&M-ohglzO7x<-y(p(by`Ua1Xus^jyqI1cgLdj@?M`ctuBPVU=w59%6EQ$iXIoXJDo1yxFc8P^oe z-|fMw?iU$4^vqHvXZdwEtX6S*i8d0u3+pDOQV15_sz-Td3QArb65KXd_>_y4dYU-}LmHdlPG;Qp83;(FaOGu=CV?Ov&Y&wysQ9 z=ZaJ#>Ym)>Dl%h1yJ@ql?VwV0YVmg&a(OFzK2;aps$zA?{nIErEEtHo??@FN#hOga zV+5N$PE&b@s;llDHCJM0c&-Gr!u)bzk~)Sz%%w*0uI4m#I()cpP{-ga;xPEr$PPU> z8`eP`wEURsb}1bdn;)5&&V?G&QG4MelM^+eqqCk?Xmr zOV_9ZM*K<5)?U$6=!wQKIZb!-wi8izO|6R7Id~kjC$3TbN>eqX)zix%r7G%f*`^}V zhuYZG2&Ffiawa-;uWN{&8H(&C+g+z3w@!dUY;GSM##6I0=~p!E!0aTNuc+&)S257L zr-;LAY6S1AQ)%)Au6se#_m6{$Zwem2SdGF9Ef-B_yNcfm+d1A27Rm08DZI|oT)*yp znx1-U6pzfz&oza+E-k_4DH%#e%$9>~(HB}6&t8=tZJ24KL8G6&KyLJb~ z5~nh!Q!x3N$-(2@ z; z>3K17o@Rx%NT)Dzs!{(&PNfs|H`)T8ikhIewfdX2RXEBq_NhVosJ8sJcOrGvN$HO{ z<*4!v+R_`nnkA;^XJL)?-_DTt6E)$SsDGQb?56N`^RItX)6y`68iFT4v#3A9Yj4s- zZHq_KID$TGR&3uP-(m5DF>HyFjEZ)}6Z@CDB;N2FIkCtGbSMqpJ}OL)x0KQg-5Hvf(++P&_I``;2BL)G7u+;wKtDp&17i#@<+8M+_fs z8?MqSoic{m^NeVy(<)nK_XjzoxMQ!jno3~K;;UNe+d@EhYKxkDH>^UBrTFDDEgA;3 zrN=n!j*zAFLrpB7R#RT8tvDt?_=P;=t6e>E4&k{2U(jGDR9r8hLOW8RmgL(hznbOi4SGh)ZHS$eF`)0k#^9qlM6 z$V?zMhfg0vScMil?#NQcZMu*hiwiU3(fg;^@pzV;UK8=GV#gUpnNjS45_5u%sWk7f zpbtJf?#}|Y(A*WD2l#`~j`HHngq#8;(-S*x$rG~%~b3d^lM4?cj66Yj$GY#JTB#}H06?(<7C%vk2`jja7?*y2g`EwV#nJ{ z=vC}oS3@s=a;-WwqEH7Visy8=L;Kv^Odox#A`2PQ(pIU>B*tI+KB z=U$CnKVe=rx66_$!p+pCMOrB*niI67JkZzay!SP}TeePF3#6wKhVjl#gTGKTUY4nD z)3qlvwY#Qgz=E%$zb6wwsV9{Fy_tHN+AHKyzaOPq# zo5RdkG`=rW+cH86X7*EGm8GQ*%+!$aWy5|iYrHxWB)+W`4<*BzjbWLWR-Ki@x>gz6D=dG)|b(LOE_vi{~ zeX6AI)s@}~yiZqos^oUkrm@#3+@_%W0@y-ibVf9;)}~mLlFI&N z85&wNZ+tC7NUQtvY4;OJLI4@71e`B?WWC!Kx@IR&_?9K=+ zoiK96d~|{g{Sy+#otcx4d$+M!etT~G8h=QaQ}`^9{SmftLR*r~1ERXRc9mKr$P0tX z?$s8vGc$dQwr1_5K{oAX+{x2oxp>VB@+|{60;P*w`eU74u@)TR6Th&hJ1$-Np`io4`2*+F0m(L4eFI9 zv3B16*u&V}Jwrz|?7Y)B4W5o>Icav@O*`7)U`;CQXo6Q{#{(ey!M~+XA&QWwd%P&x z_cQ~@#SSdONhN`QGo$K3A?ol?Ch-nz(ut4* zcH|SB1&T+zn0DT;rMBIcVy~&27VqSoL^?;^v{VXXl)?joM!4)Q!02A^5lApB~Y@=OcPd zbE6?hcn2aqst9{0CK9!8XclfX#f$p$-SZ+t%0Cb%jgEqJcd5e$eG3XXfjJE?l z=8XY*7Hlep$MXc%G8}owrJQNAKDGP*8QIpuB%t_pwrNvwsPXbO}ddgd})I+qWDwVfpDNzA%;b4Cx z3Arr`0*7q+&LY*fXQ@HA<-RtIB3@0!Ay`{SQ%+OBw<A4ZfKXTrR_nY8>I*8WAzMCRc{T1H7FgQFUs{g^HO&(YUW=fapui0B6 z(8Mpoo`}`sUGVIZlWfscLc4HRk7G74+)qa}iKc*(U}4!723dIcI2crUvlElEil#*@ zMxSvMcHr#0X)2{{H><~|=CF-PG%e;3HjKuPrG~LjzbQl`7#;M1H&EDzJa0+PUuZ`_ zQ}`8%o=;CKPIS&=(~?hM1m$BHFa4m9n_u6&OspPbZ*0mWa}bH9@=2&KBBDatt3&<@ zassRzxAWb(P@QjEZpk0QRY2i<_{V5Y1xz z48^IJD%}ziwc#F}A|Nh8QQ?pYQ1I9fw(cABVEYmWx~OzVF|l=mllbUpNDcT9$$!$+ zLo{4t66v#L;Cn6*t5wN~rp>pZELV>l2iFpoI3_2Lqw^lbi7cXN3s)*c(?^q31)^yy zQ5mczI#}$B;X_*RMmKINYgow)zeD6_-Bim0e9Xr*Xn6XtXxhdCJlgQ#5p4W!s^hS{ zfqY=%9!-m;daB0NBldAMGZaoh8d#7_Vnvbn4^ftPaF#)@GdqTD zT!W*4HEJT!bdCxg5l!dPHmcROt-~E-B0bK%mHn-p7L%HG%G=l=*c$prh|jb0ei-jm zU<;#G(e(B0NDceg?Q>_S9BqQIrWoykUp+gWoKL0>&wzfe=>j?!Qc9=_n|7;k>KO9f zslwdmx>T48vs;C67OH6K(Za`3hP^6`hBGXh_9($f3J>3>!Z4f}(UedE@P|UsuLOtT zOxrY|!oz8#xL1Wo2j@i7J{3+KW66FcIeY}R*K|M$rYL-&7M>%)+mv8tc9JCTP!b$x z2EjX(V18s&G$pk#x^sdYRHCV)BpB2L!=q`K%8-%_5@J||k4VSfrV%9~vnJZurj(M& zZfTYlXPQQpSQ^8aCK$x&J%~E)5zz@{qG`e-<9fMB6U|W04za-HM@UT_nZPy@(KN-@ z3w~#}Urf^^dUX;W8KCb%J4wQlhUe#a(WdFBWBS-SiORtwj=KTkwQf32x&j(R+K4*# z{Kd50@DRo((JIb+Mu^F&X*4qQ19QTN?ez(W4%;FT!y#pfx$RD{6gtp|p8zwfX#O9> z1}wKW(pe6X&G^BXMM?60$1z73p(_wbQ0!7Gf#1{U;03uCl69q48Ui%099@;cjT~JA zlfW4*^fWk=^TB3;Nj}Bt14lpywkr1~;sdQc*jr4SsO|F;j5zVWEeOH}X&kg*wAnzl z>64`GB%N}rN87$?bkoL3zwfo0^Eo5a4#mar>>Ruh@a+=SXk19Sy=lFKyzE1U@t<+u z>mLRq_9)ape;OMKA)1*-fVOFVAAxs)kQ3pzQ+OL5@?G;s2h(hM#yhBIx(Kq_$L&NZ zsh99CZS)xpVm7@&-plt9A%13yw}`p#+2T@&3AqJlk-dOq=-)=eIC31>q<<{~N4DV) z{af{rSPR~d0x=e(jhVZ;2dY}OZmrtBY1^hPRW)0-Hf*igQV&MR)CfEjt6F$YA+^<8 z&#J0EJWTa9xid{0o)Me_%lytUx$yx(I?i?Hv4;BU`fXL!WB7k;WT>jTr>3fU6r=v| zp=uaDor^p@Ta8f;n|Pp@n#Q$9Cxx=Gac$3VadlXF`Blrw$IdM*f=@~{y~NDnl)N+~ zY3qcJErGW z;^0PE$v-D+!hc`E%*wP1C#jg|?b2sAQS$ zI}tY}GgQFWBXYx(X%r2^4L}rxVIXEfA>FLdl7V7xN`~czIf^gY+uq&U*$2+lw;^(& zHHhD$N&FPA!Vjng_qX)+;|O|U;}B6_?0HE2`-f-dx2U{qP#cFax zL{sy%c0v>qC6wfg_!khtBt?fFuDrsxixSjDlETH;PD$zV1a0E;bx3g=PCcAUw&Bd^ zjwu{p;k!VJkqHtC-);&ovV5)kKxiNe-hVcNW_;fl0@l@v;$;*n;?OoxTu#xznn?+Vak-d^zZiu` zsTM~+gIg4k+=qp8QQSwD1#2kGtGc52LYCB!ggs|P@gPfDAql~l!Tu-AltKCNC8tM6 z>$gE*9sCXM;={o)(`gFMJ?#di{zQrrOyXMvk3iO~1PB*ck9`&LCCTJbe1Nb%xYrE~ z3F`?`$>;b1uJ}28VyR_4Y!;#@XhH{f3t>G<^+;h1nQ)D>o_q}G0^Cd;K4?8fDfp7f zflk^~=&z8u$7r(~?b!Z{Q;gvh_`VZI^1@Q)vl?wXuC zj3d|29WCN#nmdd$=!S*=Jm(=Hz{|eyH<18GZ2+Fcador8f4-d?k{qVv*!(e)AU`ZY zL-RM209hiz@f3OkKetBYizIwfnZK1VQ5(a_#7VM3N+!}H_yFf`BT*IR0c5bIzvl(c z?dTLH_$Y^73W~DiNP5~i8pOYcWkwm8rl@HEm7qr#W*OcTa0Jz$@b4u-0a%r&I$lB& zTqdW9Wl6kC;-wN@i+^ZoF_nv~ieU;Mg!fyp{!*4u8KYB3d$a$;4{6o1d zJ_9!|{uFE)x49Ck0#Ypp+Zo0baj@8*GS~Vsk+Nx2{bMF2g)ruFRGX9LM+3+`hw<6e z5rkNfnnguPM6?nQ3v-y__*F;`8|N@I52LoH%>$)4{-6?zCqyiOqonx!PP{zgP#4;D z@1NyZ=U3Vt7Z{h#wh%3IX@ZAH)S)A55Kk=}$UgZvJWFM5^D06Ow+{h-~}8$>RULZHBOe zKiFn|RQO+~OEhnJ#E1Wl9@HfoH?KnY|45-Fuwy*&pSIvR(WEDbMx`PDnPRT@OX3Ru zU&vOspdPS)e*)zt3^M5ks$CpW<2Ma5U04kt=_C9FMgn0NO&UiT3V*Rdr2%^xo}32V zir+Hm$zd$mbLYjsPg9_;~SSk{U za3V02p~*us|K%L{CYTo;XjCKoQ5M`*NdpqrHH3e;K?BZRGLtAxf2FY>rTHM+K61Uv zsDTAPQRxg4!e3>WkUT3Yu0TY>YW6@Pr-G?cLP=(>68<#?Ro+T0wZPD#{`JO(pd|x_ zFO`1-hbTBPJ%mPaHfPd86XxJXgW7xumOpR(;=prTN?<%8_LA;naoyDwAgu)Va*g zO&`K>^wg(c&CL(l8%$$fh9jQ2Ca&QGLUx~_P9Okx&K=6}EWNj%s=Dthz-a-~rCZ@?6bjpOjp-1Jc<`@v$B|3((WOpfA( z0!Q%jx}xyk#Nw04RsA-}b?(2}{34$8YCIIOg12bS{VnFVA%vme>mC-hQ`G+o|E-)y zuKZao3%7BiPgBNFEGiGTv;29s6;@y=m6kV!{|?r?K)HiLW$#Xwe~IL2R=6?lV$DmH z$#G{WxSKQcT~R`Fae4%!pLPPkm0Hg5RuHy5KTllF#o{tyQ#Y*SVF zA2v?|;MbyrS{_|;VmR1|41oGqJ6wgtF6Z%MwLNC}?=i`eR@;^%{EwJ)bD50^CuUR> z(a^w61tv`LLW{% zBr#4N!JMAnO618s!3w%EU=E$8t@gqq8I4-EzRqjVPK}0EOFi z^t6hii!@AYM`AaatHEZGXhA8-TekM>>rT?jP|rZWC_1FUz8XWFC3G6FMIyku}x#*Y%A=X7OP}&JO79om`YZyC^c4G3C&#A)`8qUp^EVbr% zJDM#@*lB2@=wc1s4GVN*fbw%dv%gC;9GkaF;?hi24(oe&CWafEYj>Ars+$M;VEy=L z*3$>`Y)7kX@4=b#MJF?XZhqaHilX;uphRap4$eorV-ZE~&CIc=l^;?0q@aZLvguVjHZR>{=9ErGZ-dI{LMK z6ZEUy2}r1YT&=-u+Tz&0*a4-H-C@k#1Wmf7x%%u zICo;8ch^tkhquP%JVJ**nIG;KC`H=)j zVy@bW}+;epqX~tB1xxHPU`OKNxK;6a9&tXb?A}mBspY(>z;Mrn<=|PaRFwtcv!j zQ%7^}=2YRQPaVg-l@sSPr;fvX(s)b^%760~(0B)0N;v$QMo>tp@}ENxYhM zc3cROLQG!rKEfCO6Nzb$^0$9QGTI}3>92^c-TlisqdTpOn;Ml!AKpJj(cdiyrlA8Y z^W?==^pypXcqNiATX>(-^78i!Mgk{$YhMrck7zNznmYz%#I80`^bh$loyaS__G2ds z-p{|56NruzL{gYu#-&xz62nUx(w^zI^k5p#@BMN%|8)(*FKf=#|` z)17YOo0>k>(%OPygI8gC2JlucieA>#nBgY&b@aEi%i_mC6zkpv%(pa*Gm*7l>SLIz z_QktmXr?r2__l`J)!EaGB^y5H0%uqxP((=UI~pQ^_ikz$C>wtDrAi+_@AKUpn2cmz z(IEV|&9Ro#*BThe^dZB2@l|(ya2qxw9uI+WXy8a z?Z^26@%=XDpB1LR9p0(2PO^8rx6)x1GMU#DgmQ{i7Oi+B({d<2hPxP1@NzEzg;phgeO`9+Ma}e~==8b4v6dbh zwwh_JtGIyHmY3fCFz{=YJlQqS+2283P^=YByjWCqY2|W|qL-ev7twP;T)vLd4HAN- zR+syH@jkMTAZ-bh3}g=1_u|j8;qYET4=MWM!-mp0L?xjKO{hrGL%pWL>ZItQ8#RTU zNR0@6%Ohn{^w3_PN&dgvCfP9sGR{Yg`0lA?z`zeuIo zB1zzx6g|{Zswupr=%KO2N=KAQsaa<;s0f8aN{13~n9oC>)a1K7r0Ai(u!`c6kBQKi zHL;ArHZkgwqKB$w_seZW=CMuOu^^hZj|oAd}%dT*_ju zf7J(w@M4dc8P3BYCDR$s!(k;y65P^7c!?6S#Mz)8UaBcvhVyVlNuAErA;<`qDV@%6 z9$uD9UL(Tgx#YDX9A&w^yV@NbM7W}fOQw@Z5WEcM;pLhN;|VtbxJ|kbQ^|VSbcx|S zyh7dEE{K&%LLI)ta2{UemD`M*;nTcgr^ZFNN-3}<+0DUfkJw>253f;T$#5P%JwsyK zS9mSUWvS>4=ixK7XZJ9ihtJH=D2DU!I*-ajTfc{L6pwg@+8C~`2Ihg))BG8oRotzJwP!+ALF1!Oav zhuge}Y=-mjE-%6C@F&4Cmp5uFhaM5BKZJ zgkm@k4`_;PhV$@VU7dsBJiJc>WHFqF_vg^+4CmnkIRM;;UdRfbaJUTT;kWTD#C;Xb zU^rj0-uoJw!EnBW-%`&2-)FoVU!>%l?-F7D0lR9~;$+EqS1(q*_>!kM1_?WAgvo!m z2_OCK+a?P5Z-XeLzw}9){(}AxFVl3@jP(Fvu?*`*F)UXJKZWF}lqC$oDw+t;l|w!n zq`*M;?rw4&SwsOWC3j$bL6lOUW2*=;0vBOxaa=IWEmRMh3?0~4GV2iw7LD#gt)rx~&yRjOuk_4R~ zKj{;z#Bfsa^Ld{r;6EV6%I`LSSXqMMK zeOSK}ElPm}D9INiS{;NE#Ysd-IhZyQw6uv`{FmlqqMa`7Q*dcDOWv;IOp1ws%*mUJ zDZCf7G+4qHAqvQn5LFC3fD>=wVoTSwZrHb%R!B}#u%ojxz6+K1=9^lm3+sJA$W-Ae zhUG{s0KU0ctl^1X7j4~Tvi-&UxkqfGnB7J zLfiQOb5Ke|V(YUMZlvF6x=w5Yk!1UkkDjHX(47_8e&q8TyeeABWwQOqW zjY^^M=|?`MO`fR-{B*?weL2jwH%kEC=|KC=DD zn2yRvwjY_$Q45jnM-EA(T(BSxM%v|egvs_J=^9nQuu6?=Kk|yE!XT}a?MJSuRnfd; z`;lL1Di7IyBI?+7r7Zx zUZ+(yNo96_kVA?)_G+v21m-Nhs+GPi1azmiSk8CT$@a?!wI%JiOSWJBLrpB7R#RT8 ztz>7B?Uz?+i`H~MXEnQgK11Pr!zzDSQ)p!Sj!0zte^EDUm2>C?MMHO*7@WNR#K*e6Gty@Ux0leWz#3PR zlWaeFP@;HFmqE549n;g!Alr|A-5XIO)Q^5QBc85X6yRJr_sb^Rk46GoS!lfW(F<}b zYDDxoug0~swLwo(F4=zcy#x@nPC%GqT574Md<)Bf_2 zNw!~cS*BViZLc_)sm&m6uXs-;fa$H#HYBTk#d|aL^unmrmuIRq68DNLGL;^#_KGVr z)jBtB#rra~I-7gNRax3>M)!)VGePp>R5sau#Wnem8p*GyxK^Ur^5pkan{2=0R!@8n z*?z@sx{gX$mEP^T%2RK5=$gzryHi(Y)Yo0Q&RbV^>ngpT?$H%kC&f_@Dv$T-N^b?; zr>i{G^8t@0N7dXf0jemS1(=ElG>yGR;Vgkv=sqU45E-2j6|1!=7Nw-Je_4ixzTZ^5 zmLa4MO&ZyL#k@8tqvX7L5JFcxrg?nml=`A#M4Pqg8jAI@rlWdOWcw8{Z9?Z!)rg8O zP)iziY?m2P$%23xK~ry>GJfj;xTQ?$F}EC;a4otyeRA_ z1d!2==T^E@_!VzR0DZ=#B4;l9iaKplsH9Dr)M?V9qDz}2I#P-w@Bj1yTB@2ewHcuk z+p!|%vafh?0R%S2Yct2p_{>#bv0R%)=0d>8Y_9r>&*p$ST=f-A6>5&^q$6oGZLa!? zcFmW;LAYG?70>0=YFzad-O_16jyO&Nj^B;*?YiPQ{#tI2Xb#HLUw%v?xRE;mHyN9R zzT#`_>maALSs>eArD8%`s&zoQnBglHYb&h|(37Vx$)#0$G}TzzEABf}4fURp=p}8{ zG?S&h;@CP>8?=~+E*IWpqT*jPd2W{WipSS;RQ~8BcuZ4KLvXwiT$c8VMH^Jg)RF2e?aM!@t=PCq#nQgKKUj zKRnbsJkcrHa#ub=GVo7jC9v|*^AW#*5($naXU7sPI7qgC3!;iuXWZkJZp|g_8$7Cs zxz9nLH-*!i=vW2E_QCT&CNGzTG`+n-loqG4ArxA~TCk3&k5ePIFQ2iPoq>H@Y>Gx( z+m{+l6D8tedNRLny;s{iHwzVc0{eYcwrYKDKFG!7UF`RToCJt;53M$J3<*5L2}Etx zSq>*7sGcQ}Ueaag1DMh|zgkl1fo+2SGw$2HM~DsMP}5U93@(%nV6ag+Cw7z#Gj47p zNaO6dod`wUX!QC1uhF;B*n>ZNHX8f!XFq84ovdVLz_=5UHaYj(DrUHcn)T=?K)iCh%&6B=)bn3x7g7?K#>V*f@i6o zA{(66IS6jg1UH-o^o})liH5;IsY=xEbDk6_H$I}}`-_OAa7L|D?u{SSKtEv69-~H_ z^A%0}Yg@cUockkNyaKlsJ6r8ScK#ZR&s&D4rhm93Tcv--V(~YylmhXX4AKHY&&gha}qDLkEM<#wO zh!R55WjaYHip`u%oP`$0F^j=zI54jxh*r5U_2$Qc@KA47A*Gifq-SzjH@`sX*yO3XSU2Yo z$syV-TH1_$km)nAb3Z~kbBH#J%61~;5N#GMqmVE9Xs~b@G_4BxC^mzpKS&j)7&NWZcOn_ZplNM;0b!fA(W<8aLWhL4opPcWG-cRf z(3ByYK~n~pLDOpZA`&15&9~!k$tL`K8~-@hbXRa$inZ3cC(-;RX(cgeTIV?rP4t); zf2}4G=nR_H`F3uYFO#S*tr$r(22HD(1UiGJ)j|@TLDOm_iO!&D#Yy5}(6rh}1P0AU z6r5#RJ+E?ZZ3a!Nmx5jfO=}O!GzLv8L65F6Xj*$oPykv%s*Zm_5?m%822E?I8q8Ww zRSZ)AAxy%AH9}dk88ofYT4+M$oV_tBN@mccG)r2bp?`Mbg;oawib2ylaRgzTLDRbU z_s9xDOx$N(!nY6=55t&l1FD#RD7VE4+`RbrFmTlC15g!^N-=0!DYKdQ@Wu`63iEl; zfUWqx^*(cq+4ppEJL@WwTkuK`xt(>jN$FcFJ>+)QHRkE1c(Rp}5Yr{Mv#vGCpf-Zn z&qHo!UB?u8y^^I*lG|C=n?FMK_d^D9JL~=CD_}`GxY9#zXWd{@vzj5PMl5ID$l_xw zz2tV*O)Nf%Tsh=+*3D)uGI}*0N|D=Hx0o#u-h^Cgi2- z+|KgnNlsLCAgr^=?W{Xk^8)2gC%3ciWcim!?j^Ug?qbbLD_wFs>u%1>cf~4H+XLop zTw6qrI4Z1%%mi`|#zTj!4!pj@ko;PlW>e5%82k)u;53JV&U%FF8&OiTvs2T;8spRv z#&n8W^rZPs6h0~$VPa9W1*l&L5XTWjSHj@YB}{SrDx~MKs9Muz8ktzTGB1m&HOsNi zw~Ypb!)fy)uz>cJ8jGqm&mdTe%c5!>HE%%5WGIqF)jDBPM|jW?P=9zaM;l+sEUMNe z41n2;f=8Aq?yO7A+mHxM#%58qPI8QsEFj85>pg7gSEF20M}_sM`7Da?rYeU;)q29D zCjW-vNVb45*`#JI%qp_3pAl}6mAtuaGU4N2LWIfRch|s zqDRp{wHD1myG7F|T|k0Ds~x`;??nf2yBAI(Io~O?juM9YijR0OhAk!@m8wSI4RMX-ZE*j*h;=ykeuSyZhz9!6a{EUMNYDI{4` ztv_9W=hRqKtv^#theg%;3-wo9P!Ezt)e;7EYYkMpgXmm+26bPs8p)z+6&deB7)HY^ zs#dW~FUg{6MOkp$N{2<&T5iw`u&7#<#u1d} zgKYaS*HuO*EcglTJeU#Fsxqjj1B>d-h)7t?9!TU=Fjb1fqH3)%sPb0ZEUMOe)}LJPWN$@Cy!0?DZfPRjbul3Nz&gKqbUE zgdnr1T5TLG!k{n$V7#4VonNE&&y#Db5fZ4G7guE5~?5S z$v6zIO&X7=Q*pwCzuXCfL6f=#E+%B3VHV_fpgK$IafdB`&Z6?Df_ zkY@X?|BnZcnY?}Yv2BhL&DYwFzOnZXeW$s*4TrlbO-K$0uML!KEN)lz0Ei5%pa z!7&X)L|eoHNwgCZD}v*ip6MIl=bc5K8Jt)Eg}whoo*BGI!_b25!sMC3LmK=okY@%b zHGBqnX7F&9j-Sy(o*A6V0%enD2B)(@F5zV+d1i1X3#^l82H%yX&Ovk-oYhbcQKcjX z!NPekt!dv9d1i3#Eyc(n&kW9Mu}(>z89b7OcAv~)5Yf0cgGV*E!H(#S~RT?Nid1mlx4VFos8N5bQN~3bgGlSP=>4xhdeX*@WL>MqcHf$DR4GhidqJ9JRN z$8+Lb1|}Ex!MwO!%!R=x^21#QJw<;Od@?`WW%;w|#DY)d$GS;7*bn8$y6N&J#o*KV zk#4FI`AmK!0c`Tj;D__WJmi_dkDLm~0phL=1u_-zfDlRPu{9SxC(JTv&+ z92hToX7Cja!b4aFKc)!2sv$CzUh>S~_cUY{d1mnYns!0*%-|1lBX#o3;14y-!sMC3 zA4#Z}8dGPy4E`X(3usf zoFCwjX9oXSVe*h?247PU%4rVr%-~NHWC8Nb;7=KrNuJri79ST}@=RI|#dmO>JTnDA zp|u6Srz>ZqVXP2mI;j}m0RFgcXhk0;sZ-y%+|WAc76Y9<#D5N2qvEZfLj>s~Cj~G5m;};0 z&iYe50*=?3e`$XK%3dB1?T=8_9IrKh+0STLU|p^7FQbs-wdOCUXz*I2TaVy!G1Z~t zwdRj5f~bJxn%5eot-RJs4*n4_+@qdL=AL(h?6p>Mf=K{Dg#5J?Hv?s!?_P5=n5GcpTLNLpAt-Z9A$3hADs$IjRLlC`-1Z zT41yRnov1qFEB<$$&PB2W=T6V^v_Pb(CS7&IjRLtT#T^os1~^R`$z#Hc2o;o!nY6= z&%>DR2CA5UD7VGcxOwsCVbiGBN1-Ypm2y-Iq|6rhIXOo?2gXcF3SsG_6qqz$#wU0j zvuZmj*#exfYC9>}f~Y*|IWWcXtMsFu1JmX)e5_yKsOP{e$2#9WwlyUJX+DFsT|eqM zFwdY~?WpI#QS(-$Oh>g!C#Ap%lN!N6M?h`iVvaU0k9rPV!hjj=sOP|?=G{mHhql^I zN`aFc!C3YLkO@ZBj>GKmxcl;jN2Lbo6e}@aUKA1Z7xUV{4ZvL*5Qs8$7kZp2O3jE$S!&wpdgKg$0q1Wls zby5nv@eUZGXERlmd$k z$^*=Sos;PPD+7tj(n4Q)N>%p0(I1LV7Wm9&RsH- za8e3X8st9qpncSHV3n~47W@Ps-^)%)fhuD)ByduC1Q7|V*#n833Z_bNoRk7<45~cm zsOP|X;~$`vNAHTj1`bh>y^;cFb0#hOsOP{&gW5bfDUo^NC~*A3G0b*S3bYy#9JR|2 zfZi?6Aq3e;DbU72`>5x@E`vsMI4RMewRF@o&nd;K?+30lzXe|*l=2idfsDwboz zJTsuq1x}pyQO|*^x%nY``ccn;YdC>W=26dqYfT!pvW|KVT<3Hj>Zs?y^(IYWU=rjF z8+gC@DxUNp6}>uVIdFqX#Si1~c*6#6WHHRdbJTO-CKjL6j(QHX$<@DK+nY#;R;c-TA- z037v9EsriaGThI|0H}Yp!#L_Wa5;}3&QZ^SdrYz<_o(N$hUD{BE3Kg0p2AzLbUA@e?X6}FEtx?_lFwVs z8rIagz16G{3CZ$Svr#q z>)vYCyRy_dJd3PZ4VC4sW~DXlTk=-3=H60_3~x1SUW;`~Z#C;k7TSF>)O_Yq&(={5 zp4(f^I;KJ7M`tG?*IUgxu3;ANRiMTg`gE2Fc^CX5FA+*k-(5X4Z|GK8LrOb(5xFz+26_S;J*|t68^rm6_gZ z)~%Y}`N*ei|F#@jG>=SgHS6{TagMi|b;p7*$6L+1b3vHvt!CY|AkOhtv+iCH=6I`F z_bdo=z16IH7sNTjMkITyHh&{snQ4x0?09f-uKh&3aISE#$3cJ(Lp& z4*-w1n)UF)Fvls#dgK&1+gr_gG$&5Ba{K1wt!6!z6X$-ZbiB~4$8+M`Po6IBgL!ee zyw$8H^23$ai|Trx%nx_nYHT+j>#6)$H)#j^q5N1kU3R{)p3aYSQq=cnp)Z?|7?OAI*xw{qfq=G1YNx0>}gZvpLk zt649c8tp!VH0sZuI)?iMGREgl9pjYVYSxQ?MIy?{%KH3&Ai8qxvc7QYXm8nD&HCbh zA~Eez{`Rj(Mth_${T0!*yMH-n^xWQR*554%rlG_3RW_>kx z4BcDJ`iJ}&kGGojwVXh7oSEKg)=L^Px3`-0bq$i!Th020hRETqW_?rBXM3wzFKg;N z-fGsjG>kKmMJ;7}t6AUHkU728tnX-uJl<;7cXMF8-fGq>8ia?i42Lvfy{aKHlwNN& z>w6k9%UjL*zNTH!Th01GZe&b5>e>3ChFREK&H9mqdVSG!7c=Vz5ne#^B64`ESwB=j zHG%Ua^&^FFr*674n)Qzg;3nY#{F4`u<*jD@I6uJgRxX;O+M^!aZ4 z8MJJ?hE{&@g?xl);=*c zF$ZS7WO_y{tu-irqVn+I*u-#h2+l?2IIja&rM#;m27fsKKr41|!O3}m= ziFU9kR5@{YW_~u61T`G}6HCwG`$Ul_9}c~=*`V^RswBDxv9!gw0-^Pla08U;R^xvm zTU#ne4^NM9Dq?AyQHyLfAO-MWENur3AAP}cN;44%fqGap&LYP2vS6li*v?p=u^BfyRyi}9k{RhY z>L55-2?sZDG9fegvbl7h@hqO_!AjfymL4!h0eYfx_}DR&oqWW%8#h4qTIDz%aUP7B zOW$eCBhoJ_2WKXn0zPOopt650MY4bgS@b(Q=^C*#W!#2z-dHg+ot{AI$QFzTC3KPT zS;(Wt3h4(ZJ@1^tnB>O-gMmlMPkfkF>x~r?Fo0BYXfTbuO|fu`v0`qVI38g2saZNt zSu9Pnrh(v2jfLF_VX$P{7u=9eDZh5V!omuL?k0Dw0;c` zcr=_usPH+ylSm~5C2{=FKWI_+ zggN*CoH>fX-y)IkAh2#;7!k_8-*>)E9l8E>+aHf&4&dKe%Wg z;&K zCx#ImoE;wDd90znx_(<#^_cU2Pfb;|^N%_CU^-*flM_Q@!-zyIerTP;hpN#d&84XM zh+qcM9)Q(+%j&J0Wjy;&4S71wr)M{(XNPTXNga!wX-%o5e4@lMANF4WO~9dBGaoIcJd;4Wt(i|2{tpPe zerx7aK1wBMxvp!ziVFEGw(nX&aPd2UP|j<<(<{kea}mhI$Ebv=eA}$o`OfUV=Br;y zA>8+n@NMTjSOIjR$BvGqAqY^Wf&u=9j$nj>p+Hh9D=8ESB##MSL*Oq+B?>N;oAB34 z;%5;Wf}b9jZq80@zH_ZFLx@L&(;CsO`Ofn@4{f`#`I=Z#ATi_9@C@;t&m!c?b!79! zScH7B2&}WdW|kmpBsrcMM7$OjA%7$~N=$9ORu)BV6pP|4S|LRf=@IzW``TDmB^F{_O;$ErfF6G+)PFB$H5(?q&`R#zLCS3&F5eiq zE|CfZ(#Op=X$F#hBHZkGv*boV;P_T*QAb;9eFMpGRez7_R#i0z?W&FgSwMnP>(ls+(0sZGlMD?` zqB5@QQtKCl;X3nR5IYC~8&^Fp*hbMR$k^JPFn1iT`7nFNHF0AJ1(6>6$NAc1xTu_2ynMTiCB?{TP=HcRh))7(8{qQq`>r&LkHJd`1+Tft z`K~gfG|ob-`^fpOHkVL?MK*OOIo~yAh|&nz{f)~R>ATh}r*Uy(c?M~u?>ciawGx<$ z@{{vjZ*IIA$-rF5QO@^%b9o9`JxG=qEafMd6v(oI1 z6^x|EV`Q<6`9&vOP9&nf`_1CtLL#jcea1s(C51^~zl{1GHlrqb(O(N5P3e-;TPZBE z7wW$4@Cu}Nx#^>!is=4ml=R(W2FUop%*VDSe2ouj8BQSdVUtnu)|6-L&QP73i}Gb;+qI1{{(f-ougsTm7sjy zc7+w?)VkK>(DRf($!kA_%NbQ_9fNZuk2TlhqRjn4$=m|L>1)#SL(?-@(ijs(W2KyM zYU;?uET)gep~W8uq?BhYYiy8px&$G}%(q*E)Iv$iETQ#o5E5ZEa&RqCLHh4mM(+k| z@1pB_`4Ktc)8L`V<$w+4G24YJCR3 zk(==IRs7=;6h4Nf-X((di)T?rYusqbnQ6RG;EWd#K|Bn+)TG{}gz7_>u;67%l>T(_yYbi}Kt)jc zvz7Gl1%at)x#Cp%|MAFdiGu$Fxk?M*wAfbqW9ulTGe31`YWnDuoS>J!R!M1K%Lb9H zm;Su)DnJT^MR%l2wlkk7pqOEM)pB|kQAozO@o*$S*6HOt_^pq(51Env;MXhV~zLrlg>|H#750KMZ&$)6TgBRjn;;R8%W>0em%_Q2>&k`ff9Z*r{hatLH3 zVK8KpBz7cIijI{ZK8#gDj#glByen8FBNiHqnsK|US!Bn={EuWel^;6{I&qHamoe`u zKdy<&sr>INKjDf>j3N>}Se{O&?2H8rF1trrG(W|L!{$s6zep-S#Y+3;rBe1%Mg&_M zlG@iOyL6MeX%sl@7R|XdEc5s~ib>C`>y}F08|7nzbK_VLrxAW)Sd>Pj{NJLsoYn?A35gofAFH9i z4Ov4KpkFFIQ%V|)DDH^w45jO&;9Mh$TasYC6r3*wsQa^|pcSbe#zFF;bb}PMO92pP zOF^d*MK%esQ3`sc0ElWS=toA7F@kK8lKr*>n9Wl1b|Z?npLBW}C;DOvQ@TZp4=V8} zo@0x#oGNfcNzvgt5zZvlxK|}3Z70nn9xZivc;>h$-ELIuLIav%Ng5~QK(dA;$BZcY zp^@a=;Gxu1(o<^T=kG|KUC!%hVJLCdUVBwmD)H&I+v4WM3kh%+d zicnC4>r(3+BvLg&YqHWP+l(_0vV!_=so*6^soiCqLGtw+f!3K(<|8=cK5dV?rB4_| zFIHiw-H!zO2fE`p!KyvZpYSvp9~Ktt#GzKZlCAOHcz0{OyX63eWfdy{>RLKdEE{Ed zQSj;R=%fKD|Lg1y>S{RY&Vb4b4&w#}`2eey>5~Yr{vm#osqwUN5mf4UZ%3ATky6v6cE)3fQ>ui$ z1Bv!z7Z;OQti+UlCu$2?5mMsTo`GgZ99Cin-P0?UD5(R6bg7c|##)n!cAT%4Y#ZnX zoiR9aBVKJ^ynmptJ0Z%HxUFZPFL}WL>Z!A%tD|2mQ!12n|Gros^4b?~i=&dMWSZmM z@wSc@7@8TJya=-T`lB6)4dC|uv)3mB4V8#ySn4_>|m6Z7?fd8(y^k1 zSflV%9En(an>gJoYw7H76>Gh+=6-R8lE{p<#X6A!x&_W@b61BrQ-ic#Fp%g^4s^r3 zJHokA`mM7*kAX z>`r)JM}IqYKB8HvVx9Y92NKCP40;$M@%Tx!0MViVvO!Yc&>8O*txAz-?`Z4aD&k6V zVVru7{rwpAlk#5Ot)flo9rt3p#Zr$ab}2P&#<6Qgv@5aJHz)ZhQPH84+;4SlP44Z8 zC1KhZC{1?{btb*Bjy`s}-mNsw41(q;axT!RDPi3`u#i36b%?HPO?!u&lXNSU{XkTF zqDP6P%`^Q9w=U7EbYyM&TiSOui#=W;kXuBblF@U>=0M$?NGOdoO}nXJj3RZvQri<5 zn0jjm53%SesZSeF5c!Z??P9MIJN2~3e$stP701Av+)EWb&iy?EeS!)&@S#3`?V||#9(YWRf_fqlM zGfNx7qK0Oy_|VLah5O0g<@Axm&53=nUVFC40?u}!%=Y_mOMA90=f|8imF=D8GRjre zF{JLi1t#$VCQ3WaW%L2+tmMcvRuQm4J~@Yl+9cj{Q%Q+GJerys2J#|v(Z3*#QtJi$ zuAfbf;R_GFe96_V(k+EW_neLg#lBpg`HFRz*3e_N(jRkO3;pq}Yok=LGw{Tr6 z|1DaFAqRp4rmiiWJ-I>EA1QYy?Lf)8{!VP{?dflh!5leeU|k31?E7UP zxUMt4D~67NRg2c?V<6^_=$`v~dP#{{BLWH7AeugfL+fx3Z_J*(hu6{2h*O!-zDc=6 zKHYvEMmg!FjNr@2I?T?MrfgkTmz|qscAAtJL(6Re%vuVf$b7$wTcPRQNXyrC#c-+x zCs4`vQsEUGX4T4dm}C+v*#ZlJx2;%(@6@O=egpdms)!9`H#nJaT{SXv3@h_v6KPte zI6O%24T4)1!H^(T`#2qbhlEKD3oi_N0 z((C*y{A-GisZJM>u`R!z%{!-tYX)ALg!gR@vmy47DsUmoO;fRo*(alYeN z7V0*MvZ(w1CK{;IKfH+RDzty@=4Ib-r++0Od;@zrxMhbf=Fy{o+%?S*zIR8n%R+8buW)6u}a5G|1niO|0p%LoJc@ZuEe-grN-K;{|Dkf!&|0t&od*$WaGCH~je&Cl9dOqy zI8)G{!o^V2MNyftuEM}YaUmqK-kHGJQPlgsXNDzg zae%OI4ThaeW|GMU0h$n&unqxa5j{PbnIvN-Gs7$-LDas8BDe*;DsFHT6x^e56&0m% zLG+@=74)LFRaC?+it;XQyx*^@`keYr^~nrR$7Zk z@||#!33kRODs18t_gRdOPwv93xNO)Roa@gy7&&KywAvtEpbWZuJWA>8;(J zEi=%P={s#(v}BKZAU@I)?3uT-wskLToo@D#Tld~0I2`rw!<{n?-nSONE!)4J&4vbX zzxH=lQT%{fC*;8g+Ggb|2VsTP<|`p~rM7Z#JqhNA?Hg2J`sTR+wuJ`FEP8KndJ%JI zThodAm@efwMti?yNj^4*U3Ya8#<(Nz`opikx(OeK!gZNhxM2yFk2Dc)TCz_E_U@>* zfOQN`H#Oob-UVO}gMUt${{d5`J{=CT z?rfwtSKyXul-cQp#6PFm%5iHm6}6`AyVfgMxYHcWh~4U=KZq2I_vy_AXLp_%Iw7Ys z%qe0IH>?QS(}i<(D)3%8&UJ5aS{?80MlajFzF{BCtzh4>txb559+YQ~!<0Z? z4;O-iZx?hSq9N4vEi8JJ-N2L9(at8U9&;GlJF9lu%J;0zhG0&x#O%F_lXc$mcK1Bh zflzjWJ;TjmMfeKOdL2Q~iR8{1cAhO^lh4Ofx`PFK*c1N3T0`=x7P%+BW8G8Yad}{^ zHy7Iuubl^vH`|>KJ)wR?}B zdv&4dBOdL~Gri>Wz(saYAqK1wUr);$)h);*sb}t{8Zd+|W%h}QuZjoZJdy2tXwmZL>x3@kg_s5^Z`?hI1 zVJBV<^ZL;UF-&tv(HL9n(c%amrm3>JuhSA0XYokMHof?(J=J>!Dl@_I>LAB?!y2cypQ!C0{&2*&05 z0KIgD0PIfb`MrJ}@Xxmy7}Ed#w;BGNn^{ceLuFfj{2Z2V!)PDw%oxnHBkHSW>K$31 zdVEVIlkX^eIM&$w6a8oEK+QBZRvZrw_Jb_qxX8Vh|@#=i=e%zCF+1oR_~fw`ZYz ze(vvH(j4H5Jq(BLWyeAFZMf8{ukbSIV7(;q-V z|5VEV(Klo~4LZ!39Z;Hy0_w`ek&Xr)<><=98#5D5vW@QJEyCHqekZTEdNy>s;(%S0 zi|h8qA#1iyEAHRzP~4f@u{hpM{7!B>uWO68< z+133D)i4S7FVx1Y)+EOC*MY^IOuUCQw@E{Lg323UF4GR?8_Pme&^^WF+jIE_j(7QL z`)cA3EzWU^cB;QwI84sXwv!Jp&fG`HR=X!h?uEYKn~0-2@pi^^O0H9=_Mfl+pL*ai zIHQ__`|*EM)1RmBg8!TFr=S2oO%oo3U>!3^NZ+fJtTc zs-B+N{P=)8CSgHaXIuMh{AFoi9A1Y!uNMQy&a9E4p|O0c4V}Gi?i@V1B(SyQPi3%A zUT|A8;cLsIzV_;&yq~6=NvTZfyP0+W#XLt;YEePPB`ml&UfvpBOgY@l!Sk5aL5E;hX-wHy1mSHyM)VbHk9t)mYvVI z=hL75^!T#oZ85i3<+J^)zjL;80{wHw&n`Kdo`w0yW6BPA<-c=I=5^z_I%dYTA7N+Q zu1#m+SqYeGYp|g?I1m5-J;It#wE%y*=Yyf_@y8k7Rn&(|wdSUOOm!XRaA$S#vrrwM zy<>ZG_*tlKZoRr>Vs#(JpT3)e&p}!K?y)P*DgTJm%UamK`tkU-{FDhzn$pSl89LpS zpN?uRdWLHG?~|B+;JE!?ash-Ba5p|mlTV)d7yL7r78tzYN4mgG)a;+!4KF-a2y`$X3)Z z15MS;Ym(yp-#@r=2yY9_Iv!JiZW!gYBx)HPt2Gi0?&%&jxy^*L%X~H(7Ez6z?07n# z*;Kox#NCV9GCFP?j><7SjRjHYuKG2oT|)F)Y|n=RR(NDJPc$@1xjHafTP}7DdyK{o z4AeFts50E$OUq)7q1{+!o%tgY4Tl%lesb2Vj|}(p=0l17UzZPey|?I$UpH7^A6oIE z{@#K5dJo44X=+8yvI(=x1AQoBmiYzRsQU`LrMtFa?dbZoHfDTefO9*~iP+&<%n)4k z<72$KM{Rh>+4xBR*aobjCpZw@{p???m`81}$M8^v`ehc*1p%I!fI||av9h1D1~z|8 z8M@5-Mrspc@rv>Ofw5WrgD3FPj8`ukkFXbK-w&EruDYdV|BdIgjEr60a_CJhql;TM zjE%QkKDNANd~AKobS$qKyRv1*87-qXEr%1ot7RQFtsA@Qie+aHpFKX>g^wpTZ#V7Y z?H+#6ydG-4XwUDrJZG%s^0qTS^r1T*eDHghwtVmG*&}D3xdAmaZMQQ2f7-+R z^(6oMUBmyHTXB_gEe`4C;7t7g_g}H_`G-@znqcfd-^!cQ<&*6J#q#P!fm&kwi|wJ^WE>_|K>;V-}WDD zK6JP3n!9#u%I`6($?q|o`_Fp}==Oia9lK}i9)o!%HBP`i|7VBdGjjYn$8-L+f0mt& zyEWmtcg@>D?Qv-d<$pf@|GSkxFb{5?HPVNxyIH;CYu8#C%8vwF^*%H5`we{PQgd(( z{{OqHeOhl{|8F|s%zhT$?mlC0hyLfkmBz79|BFNI4!F67$7uzZko|*r94O2!t1G;) zej10Z_ZAGN(&DU&>wliF%)1(M#@PBP7MJVADb~EX;(HUk+o;{=M#kb@00Qc7<9MBK z?sOxsl@XNytp?!S$rpQwGRWDPx`|2X(!>n!B+P#LB7~tfZ}iU`HS_C zCzju3IkI26H&SH;QjZ zd~D-U)mGzYVrz`}Lbi^!@#wFYH)E2;=%dfqT5mW0^Vc)p1NO98{DrAFjoS5&3F~tv ztj`T9LxYvR_5FB8A-vKSV9XcTwZf#cZq(MG{ z3|~Vs7;qi;jPR7a4Qp2n4dm;1&259@Yu|8JZ*C&ZR{(DM%Dz&`}jVyueYPNG^e&SmxxbO58*yt zH@}--9rU^7yWuzG2)Xb=S;bx$Pj)>45f{ zJF64so}IJxi^-y|d;5yZ%LyeovGHSOdC5^wa{GTm2Hn^C@lzjxXZ+xI65_sV{%Q)A z7mLNIdz;|#rsX#~v9h?UT|>cQ@u(WQpjh1Ao)21r(KIMl&WHZb%4DejkH-k+uU%@1 zx=Iq&7^;dOLo%ROR$qoa$(pITJj1%AQv$_k!0g&Hp|D|oS2 z&^9N(sNpi2nqNm?vABLIZ)#BxH~jM#MyptK3;Inh3gRN#7QDDvbPM`T4Q+uX_BWbZ zES_wUX=<_7RSzr{`QZ+}OklBw$N1zgWGohWcZM$$SgfrykiAqazQ!UGSghS!4=ffR zl0dss`xV-yW9@HrXR%o94r@5?=3?#idSJ0w?2ZX6)`~qs#$vJ99TQlrt*B=#7K`06 zfyLTe>w(3hyL0}Khqgd5Tus5n#bU8Ltl{F?&K1Ljz+$o39TQlr6?=rhVzJmA6IiSj z!-c?NvDh6GSgaMpg}`Fb-8p|+&a^vM)K5VuYF%Zwkrm5VS_a`N7K^%@gBu2l<)YFu zeJNs!22Q!He!=BMj-o#HM&nZl-~aH11E5$u%n+dSi^bv;f~aD#c(bte^u_rLbG2C9 zvzC5&vFPUVC!3A`fA?2g{{1g_ZUuJnZ%^UwLsNcRsb}IIUuHp55aN5sCT=zBYuuQi zjejw(5!{DrT8g#pEHS^@^6!%|%gy-JQj)n1U!_Y>-!#XLj)9g_8J#nM~s!jAae($tRsxrh3C zuU+NIuBGWW2=F`LV>aeFdCZ_)(_f$A>Y*^}<5x@59NlQw?zg|E=P?WMzqY5C32oS7 zXTpY6_)FueS(p(k@a!-AC4?!ygCFYX)@H(E*gjmu)MkPy#TFinZ4+v*4^FF^ffyeG1)fdW@gaG`-{o=bxwt$VVsNupfq* zGonuBf$-E@C+C4&EMzUnY9ZHwtQYbgkc~p_0of$vdmx*IJPyJ!tJjVvKj52NTyiwX z6GBb{`HPSqkZH(O&+`(Hy@k95;IG5@l?ZtgNL9!kAgPdVvoL<_FRc6#i>*TT+$O-63c4|!Ac>IWAe)5ndz&*M zH-NO_2QdE$f{$VC2qE9XS|lXHS}f!@SWATb6>C)?cw$HJULi+N ztQT??$V-Lvf?OlyDv;}i{42;tAs+yFvyjh$yhF(MLEbIo_aL_m*%6;}{IHNiK<*TB zEXb#XEC)%2ya26;fp+dwiQn?OR$k9w*5Kw=>egH(n5o_T~!!^KF55vu1o z2qYFVAEYYeY>-Sy5A&dp>UlOWkC2VbBjh&b5%O8)K`ZNdzQa61e#JaOT5xHW3E2lE zL|i>jJ4h_#G?1#07c!5Kapu8KJHJ%p>F*%p>F%%!3QjdY&fK z6ARe~q$&i@6ACgRr-Ov8Zk`JB2wBHGLSD~2LT+OoT$t6{a}V&MR z@g}jJhu=sR3t0eC6>>IXc6UqlFb{5d)$?os$%MR~d2lbX9`hdN!TZrVxtn?546l=K zF^`bPm?A zdG$ay=HtwBkW0SGJfTY-VICoWW}buHnB6eu@gXib5+r=COCpd=$VDL4nQqJ=^Bn4u zS1`|EE_ny@2)ToK4tHa|!aPT~Ojatugyt{bxy zB<^&{Wgy`^myCgALSDl>^WB(RnP-7Z?q;5aF8Ma|2zd-7TI9wAI7X{N_5=xzbz_bJ ziG?fyNrhYj5+3K48U{&(Tnmy3c_&D;*e!JjNL9#JK!W4lm>+?}LjDUR74jVDN{COn z*GK0tkVMGwAeoT!L824gQZE9j3i%h1AaY}F1c`-w1SA!5A4qtTTj~cOiI6{lWI}d= z7Dh|lQip(4g)9OIPIhCuKw=@QKvE$u1qqkBrQQsZ2>CEbCgh7C(J5}Jhe4`B9tR0d zbz^pde#b(d3z7;s4kSFyEp zknjw*)UG(gBtr0{h#(Vk5=eBWTj~;!s*uY;g0tM1Ye8Zm?*vJO+yN4v?Uwp7NFwAv zK{6pvfJEoGrFOwtu_|OHNN}zjb1XZa!b7wBoXo^kW9!2L89~AQlAH@ z3i&=ru-uK=0ul?^9%u4Y$blf?`EIFsAc>H(Kr$gcAkhVGsVhOMLT&&FE_7pV2Z@E; z1Ck2)E=c%1x74pe5+U2*S|by(A4qhOTWT&yRmhnjy!lmEwiO_;kPRTIkc}YWC2pzP zK@uS;NG9YVkmypk)E1DckZHI+;%BVu?Kub}7BU|s6><(pc$r&jB}gLVr68G*H-khk za7%p{q$=b-kl=-G%nw0gAy0s$LZkD?zG4t^!Ggyb&Z5 z@_vvYc5A;EBoy)>NF?OfAhD2b4nTW^><3a6G6y6TvJ4~>5`zTYZhO{&ghE~m5(&8# zBo^{%kVMEgL8?N20g?*A*KGuuki9^H6>fXlKtds>fJ8zr1Br!NYe9luw>|Fx35DDZ z5()VhNG#-+Ac>Hc5bY7NA4n=>E=VTiOpu_@ZBGwKDCET;k&rin#6ms*k_fpMBo*=? zNU+ka>(?NWkd}jyN60=PsgQP%V3nKaG>}Nh3zkC0a~kC1mV&l)$+oy;TT-3AkV`;PA;Ziw?B;nD^9bR4_e98D%p+to^IY!cd6apC z1cxGzki9`tA?+Z+h@0nhkai&zkS-xtfD8+HEyzY8w}NaE@@bIGLcRsEMaVBfT1VaX zv>b-^2-z2;OGpREu#jaS8-;X(Y!b2oWV4VPK(+{ZA4uz%+n#$t+J!s>(j{aI$gq%U zhoe10LXb^D7J_UR(gm_b$ZC+*ako7QNV||5LAr!&0vQ%^KgdQQ8OSCf{{^yHNb3=3 zkB}olTCZ^1vjn7F$fY1%LPkJ_g{e*iS`IN z2&7BM0+3-LT_78U^n+{?ay7_iA#VrSBIHhx*7a_Cz6#PV!XU**Pp8YFm$OTGnC74jHJ^insb>1eb^ z$UY#+%iNd_kT7w{GLTeAH%R<1Zp;Rd;A)rL08$llJ4p0$HzozigggY2T;s-U0SRB> zl4-}FJwkY&GJd5Svk)Y>)+JpaRUxZEqF1>w2}ma7Mv&w>H)az^c)d&R2T6tSE@}K~ zH|9x@;59DUZ5G-iAj#|8m{E}M^)7i0NGjw#An`^w=CdHd4K8^Q zq$=dMAkiD#nC;up9w8w}@pxd9{< zayv-;Avfk8kl@2E`7TIR$ge@7kGL`0%tL#G><5x;a%1LzgdcUuGLTeA3=)6Ljadg0 z+~JbffmDUO2PC@Fjky~n6Y?#PRav?{;Gz0|`FklI8_ykC1&qqR+Z9b3ig7 zXMiO4xG^h0!qg>Kf}}#;021Hp#=IXS_?$~V2T~RCeURw$Zp`mNG9f!IM0>vA#vB3? ze$gch86)HzkW5G~NOYfD>PnERkc}Y0m)w~5g2Y1Z21$i{6C}LfE%ghKL`bj*?GdsU zNc3g5R2xWD$SEMfSKOG(Kw=@IAgPe+LBfA`OT7yu5powuCgkfN(F1O&pMg|`{1qhl zsv9%oShPpT(IBaiB_QF~+)|f-BtnKkG9lN3L|=DH-2_q<@^2vg7;X!G@duv*1Br$F z1SA#mCy?+PZmC_5LwkfA0g?$h5hVJiTk0Z^s*oX&;9G9YwIH#On?X_`p8yHJ?UwpF zNFwCtAeoS-K%(!srS@8k_6V5`5`5Q+emN5~^&CP*q|F-Y)ZH_rtik&pq9M94KDsgQSo1V3@}+zAp1c>p94 z@(4&OBW|7d0mw^O7b@PmXghE~g5(&8pBo=ZfNFwAbAXOp! zOiC)`36M<4&P&jqpSkUME=VZkSdd7_c_6Wn)gXzGmw{A;ycr}F@*$8+$QM9@pS$h( z50FsE??ECVJDiO62nj(FAqzmNLe2q6h4g`BLaqV{9(CLEMvzd*`#~Zh_kzSi9s)^( z{1&7tWV@wkkB|dEG9jHH!7tqQoCy*NSpgCW*#Hs?xd9{*@;;ENkb6N=A>RYZg!~SK zHk%gw;tw9%bPC!d<_tCgc*3@V9QB%b7>Wb<88=UCblolgzWl&GQZB5%LS>5z=%z z@(9@nB>bJ5rvoGwvJ9juq?>t!Y+#<>yLoP49wF~z9wGNKkC5*%&*N^M-!YGn9hM=F zkb^-oA&Wr5Ke&08gTzACFprRHm`BJvndgsgo{uw+kgqe3kVlzENYfd}^MspcUyxYH zT#%}evp_N-ea!Q}+&nL39wBdG9wD2UN642!ru~PTA7L-lMB9KhTg&@IS-BRNqk&qie zVj&*|sS5cjNGjylAgzCMGw*OVG7C8pWTTK%KvE$qK^_(Ia**IDH}kC^M+mtWBogvt zkR)gd>gS86Kr$iWIha4qZp`r@iI5k9q%CgDi&<(Lm%JThSjZgJeR^1=%8G4G13#Q{U59Gmntl7z1-@J?2XwRUtnC$%M3Y;qQz)xTOvP ziG`d9vPsDEK{6pP25H^V&GQzJP{=1hVjOH?0BouNHNGxO&BoXpDkW|R~ zK{6p<1PP|Qb^QpWRmfjJ+J)?WKK4tA?1uxpW-E_JL! zTN=Cgi>Ei37${d$AEKM_Q-2jtZ)gSL7D$Zun$pu7M(XDOe2z8EKwI_IW}ooDy0*iQ zd3wWy82f~WnZVoDVwh21pTTN;Xz{d!U3DYY3Sa-J+ZVq6p24n>p`OaBK5_Tc*B{n; zm1*ef?-D{^|7s!Ufvgv@7UWezt^>JI$a_FG38Allvk?0Fw+NxHf5+X5ac2wZ>u(i8 zU;my$P6OFrNDs&nLg?#XD1^TL(}mF29}A(cKM_J-e^tn~7_d|bef^mb`uc<2-Tk7k zKNLb=e^m&5{izW8`ZFQ)^@lUu%=GoQ3!$$+5<*{pRS13kn}yKVAMD{~rmw$U2wnB3 z3!$$+7LtJ^Lg;I+3Zbt*6+&PCeM0E#e?SO*{ofQqU;jfw=Gl|X{nLaT3^H8^ef=|p(AU4O5c>KLW5<*}9twQMQf4>m=`Zo!oum9sh z=L4A@ue0p(+rj{0GOxj>sc~zWziAef_Br`uc-?+&n$ZBZR*GL4 zXJ0oDef^OT`uYmSMPGj;guebn$Y~&{5c>Lq{oOqD^+!VJ>raH- z!aPFg>kkfa^U&8H38Ak)5kg;oDullN;6OJIef^OT`uYguedZU^fqa{gDv*`V%4a^`}DU>kkfb^W4Tf zLg?#HgwWTY3Zbt*c&?jg`{~Fdguebn2z~vj5c>L)nQopQ<~h_Q^z{daxrDy{R0w_j z$>DAcef`l9E}^eKIMOBb^`}DU>rakyW9aLTj&{i`kl+}X(AS>|p|3xg<;Kw0AGNuJ zzW!jgOX%xQh0xcZw7W51Wu6X~(AOW#aS46>sSx`5leumTef?3VOX%wl=DCEv{!|Ek z{mFbchQ9u2flKJ?4;H$FzW!7Qef`NIH-^6c=vbG~*B>0`68id6A@ubpi`^Ld`lI7r zLSKJyf=lS@PleFepPcB%(AOVDE}^eKILRgS^`}C9$~;Tl82b97lU*`nH{@CBl4C$p zAxlA$Q{0%#K%!G!GR8cox#Ts>Bji@*Io*x9n|YSGy>3Zbt*JjX3XUwu@L(DQz4IogcrG` z=<82}(AS>{p|3x>*e!KFNL2`Z{lO(}41N8v5c>L4A@uc!m%63s>raHx*PjWYuRnUe zTZ+E^su246gUj3)`ubxb^!2Ag=<5$(;Fh`;BoRVieL~ZnqSD{Z%3K^#?2582b8SA@ud9Lg?!cd)!j= z^(R8;>(7MH*B|w|rReLg3Zbt*=yPM}>yL%d*PjZZuRmPrmZGme5kg;oCWOBJXq8)v zzW%C^ZT3ZbR=Y9u^~XZ!>raKy*B|z~rReKVgwWTY38Ak)dXZa-zW%BZ`uc-4ZVY|> zu@L(DQz7*AhXZaY`uY|xep{9a!dUX zBoXoiNG627{%F`OH4`KjLSKI(guec&kd+{*5c>KvA@ubJm%DY**B=U@uRjt(Uwb^z~PT(AS>|p|3v^ zLSKI{>b8fz{!j>g{gDv*`ePyV^(R8;>#qu-uRj$+Uw={~CgeeoaGhKGuR&rVEe9iykbOWh zA?+aHdNM7LSD%{Lg?!cuX6Ly*B=X^ufHmUzWz)Ief{A}+&uL4$3p1q zuL_~BKNCVM7Lg?$ygwWR?zRb--UwKvA@uc!SG#%W>yL%d*IyMvUw)#}VzW&WZ=u(oAUw@Yn`uc~3(AU3F z2z~vVgmi;!7D8YD79sTYx4yz{4}JaZLhc3W5<*}9un_wCHwvMzf0GdU`Zo)quYZdW z`uba6>9&Wy{&pes^>+!OuYXtwef=AS(AU372z~vVh0xc(MF@TUt=GEkp|8JP2z~us zLg?!s7D8YDMj`a|ZxTXZ|7Icd^=}bEUw`YX-1gAd-!5ePBhelq^z{!5p|5|V5c>Kz z38Allvk?0Fw+NxHzx6t|J@oar3!$&SOUTbahK11AzflN%{izW8`s3@}x=sZNUhNY4 z`l~|d>yKXJ#?aTF38Ak)d952mUw`;Im(bUr3Zbt*e!Uw*Uw^RCCG_=Ih0xa@-QdR1 z*PjWYuRnQ%8$(}z_(qq|*PjZZuRs1*H-^6c;7u-}ufHmUzW(UVZVY|>nGpK=lef4r z^!0}~x`e*|R0w_j@mt*(`uc;nxrDy{su246qqn;;^z~;#=<843;l|L{AHLHi^!2Ag z=ef^mb`udaix-s!TVf7Uw>5yef^mb z`ufB7yQS#skA=|JUll@MeMVkGOg0>yL%d z*IyMvUwyPeoW9aM8gwWTYeA11f zuRr{hOX%xQh0xa@f7*?quRplkCG_=Ih0xa@ea4NUuRjw)Uw`shH-^6c@E(`Y*PjZZ zuRl)R82b8ydtE|be^m&5{n6*#82b7%A@ubppLb*E>kq%+68id6A@udfUvy*W>ksa8 z34Q%lA@ub}UvgvU>(7MH*Pq<)#?aRve%U3bf}}#|>yN+U#?aRv{JTr&>#qu-uRnUg zjiIkU6GC5q@>Ms6zW(rQE}^eK6+&Ns{B<{mzW!jdOX%yb3Zbt*`i2`rUw;kR5uUw!FOCjUw>5yef`mQ-5C1%t3v4O4<2-5=| zp|3xD$Sp-*eXxFfzbfQ5kl+_?41N8v5c>M7Lg?$ygwWR?KIZ13uRj(-Uw>5y zef^mb`uf9Px_Rj9kA=LFd4$l{p9!I_Km3)Ohra$;2z~ukA@ucULg?!cf9>Wu93&P( zUw>5yef^mb`ufA)xOwR7kA=|JUll@Me5yef^mb`ufA)xq0a8kA=|JUll@MeCS);4 z__&+r0+3k90P_gBhIxd%gL(eo=DCx3ggn4JLLOlrA%9_>Ke~BloP<0=jsd9(SqhQ~ zxeO$H!p$=R5(#+~NG#+gkVMFxAXOn>0ZD~qAeoRSK!X3})=po4D1^TLNCKPA@ucEh0xcZ3Zbt*6GC5q@F%xD^!0~A=`p|8Ixgueb%2z~vT5c>LqKfCRruRjz*Uw{ zp|3yqi`yRh`a>b~^+!VJ>yL%d*PjTXuRj$+Uw`mdw=VknBO&zlCqn4!PleFeANLqr`$aB^+!VJ>raHx*PjZZub&>a7W~g2d{hf05<*{pB80yF zR0w_jL6e(@zWzuEef^0L`ubBL^z{eLZXWvjBO&zlCqn4!PleFeAGEl6=` zp|3v`LSKKdjhlzQ{zwRY{fQ9z`conF^#|L!dFbnpgwWTY2%)b(6+&Nsu$`NSzWzuE zef^0L`ubBL^z{eZyLssAkA%?Ip9rC^KNUh>e=yC>LtlR+guebn2z~vj5c>Lq9o#(h z^&cUGzW#+m=<7dS2z~vr5c>Kz38Ak)6GC5qypvlyef_Br`udZd-5C1%Qz7*A$Gf;O z^z~PT(AOVKcVp=54~5Xz9}A(cKM_J-e=3B&{!9pc{p~P5){k!b`ePyV^=}eFUwgueb@FSitZ{jm`G`ZFQ3L4v*AQs;uS3Zbt*6hdErCWOBJa341hef_Br z`uc-?-5C1%yM)l!p9rC^f3pz!`h)%4JoNRq3!$$+5<*{pB80yFsu246Ga>Z#2m8Bq z(bpddp|3v{LSO$TA@ucULg?#nKfujQUwkkfcGt<`}3ZbvRT?l>sT|(&VkA=|Jp9rC^|8+v>>#qu-uRj$+Uw;_7 zEu^nM7D8YDMj`a|SB22mf0q#Y`ZFQ)^|v4F)C%l`uf|kye)o=_upKnaeMLl3>K0@ZT~dwTHxC6!q(C(B3BOyKHq69BPl^<^-`8PjE*iXZ9)pYIlGhXHAHFz~Tbgit zy5#j1FwW;4@zc`8B|p`BL4O0xRTTVvZjG zazB0+;%7R3TAH||?J4H`>uPgjc%+XH5^*O6N;O@GKAghbFfpvl-=}AKZgiquW^QbQ zC4Cih18-g?of}`qy9F~ha48%3xi~lG1Dm;l6L86k;~wK@vT?rzLTAQ(2+@8YaZIx* zjOj4q%$WLftQgbVCyr@{bFicQt{BsJ3S(+wo}Dq}44rIDc^Gc(e8J=WyLhiM*_d8C zg)!ZTT$7FI{Zkmz@UY_i)%ZBAqOQrt^m7x(bdHYc!5GuwDU7L!d3MH>`aIc~#)z40 zOn-uRQgyzs zjZ+v?6T>mxj0@xAC5eANjj&y>ll*Hf|NK^5t1m@qGp6iqeHG`^^}v&j>0fb*G-JB& zM_|IyL|Ehb^vc?p{+d;KFJ5c$3ab@AElvIYi4vUW+z?wP8}~gh7Uo#~7&^yK#cQp% z;m2HS4eA9FIA8gBc?xr*y*4+xP)bu3=j8*@ioZRDFYIjU9T=$e4UUa$kOO`Ib0fwZ zC%)Hf@td2s=L*DxSi-Ia<{eW4a)glAg0u^H8%Sa^o3?!r1k=#T^Kp>q08@K&P`qz4 z?crGb6ww@&`m30SAsWK0Wo<6zAxq|MZem;YRm?;7oSBDO52K5Dcny}#Je-N89k@we zyaw0{*Pvz|9)b7whs$=Za2~G0R5#kP&~)R3D9*!oV+`1mmZop|2M;*sVHaX1n}=V* z1T*vS)u_uKSkA*~*ka~k`E>&4VR-oD*AfZR8;wd(LJzTG9v&<6kQe=JJw1r#Yw5ti z*?gQ}S1}X(=GNwhiDCa}J+72!blXmLugS!4-2HuerpLV(O`L4p??lXGuP zGww%e$JjNF`=%+3`@MS<*rH9XD(nV z40N5$dl+j%Iw5XK=8vJ7HfCl2Kp(chpf+0?-&L#CzLmRb-BZYu6nn9iJbhEhvvCS} z`lpbmI)yxIr;umU6!Kg?g*@pL@{CU*&*mxQ;j{V7RSG6Su>14)zx!$e$?`m5=^g3u zwt1Z$^XCQ;3Yn{v;#$I#qHY|GZK~t{XS#8^cW@Qwi`A&X=mvIY!mBu6q~Me3#!s#+ zbmR3$;&Go7GMQ_M8)~|79F9Hz#cPQ%G{#&@e83L?p|)gG(3XX`yKk-~-rMk6;`G`% zWl3pWpJ827(4QE4W6miNO6aZ?*Ah3^W=mt0Xg$!VVClVgt7Bmi<6k)h#WiFV{bOg8 z)wqf>^El&{pR~<4%CXhsgKL7osmty~ zd$AYZynK3BM72FF%VYLy&WvKenz)1^cV6~f;P1QJKX%_gy_J10j@)N)zdG;6e&plT z#Q*hW_iNtLVw4-lEEp(8nU6l4@G55S*K7Me(7$3;Pmg<3?b+OSHt!|)8M(Dkn-icm zyuQ>IuTCGpRi(K~Iav=$8%ibN3^!M&A=dm!^j^>(?o%kqH~au>=hf-;H6=L&YyOK$ z5*|^!D}fA7coqG8;10z(1%H8B+dsH!7XAd)H`rUe{XHD#6f?&{oE;`4!RoU;7RS}v z!?P975q_hVA!Zm`8eN@oFD^#R1NgnQv&<^QoL zq;v5^vS4O$q!ibXQz4MX}JUdT}>Ac3vvw337g0s9lGbYA#zQ)V* z@Whw}U0$C3C&qOCtCwfX#FzyaczI?{jOl!bm*+1NV-{TOSJ`?>Rj z6JzFePRz65vU;hJ(UBgM;0y9=uMozdHhevW`;Z95>+M1+75i-x#XaggW;0@9t3RgH zZ$XMPtRXvHl!xY74cQmuVykS;!SG1`;Mhu>n_|F>af8zSyLx@5O;0X#+9uYPlD~<71 zI!o#^^CmCmK9Bs_E49n>-Mtv;GhJrxLKH3BA2D0@a{KT|ki}?oeNQ70ZS(maxenw3 z1l3Eu8KgK9nO?nxrLb7v_m6`-ET!%TDfHQt`Yy;eh%u!wGrM(W&crrXV2mUd>G*7X3WaFLPCt(ffncGn32)DPGM@&&8sj=j1%5)!FyUY^i#C z20<_li#=VrcBr?{!b578&e;PPkQ7lmaq-YO^1}$ z^+Uwy@wEjc!_aZ`_=C}Vfmy286@u_pCkrhhZEiXk|NDJ-He#y4^`q%hkmBmX)U^sk z+jAX=xq}zl_S^`KiRq`v+GJ70cZ# zR*dvrQLGL05B3$yD@Sob>(0GH1o7?X*mm;M+BRn^ zxwTE)QqMPWOFi3!*3Ut{c|}bVT0hygMy*G=1}%|{(nfBn<(s&ro{gt$_gy|QNwjL4*D9MC9#EkmO!kiXs~UVgjP z3|)h*Td#U6$xYkpo$lqY1)z$d!M@Qs^X6CjhWi%=SN4qz)z{W`uRrUo<+Y7H{Ubf+ zukK$tmUrEyb1EmFbK2Zs0-ak*=ate0rF2m#?dT}S<@I%xSJ+vaV}2>^XfMa*IXV`W zM$aklq&ekP&MmL9JatEd)a5zmlqZ>6-jL4not#%*<^1w0JIZs)z3gZ&ud`!Ld8Kp9vv-zfUs#@`qrm`mH0a!p1?9Usr@g$|ISqPje)+yGD$m~0 zVDRQN7^XQ5x_EAbxzW*J;&m)4@8h`*hJ+$iHWB77EZ^NcduORQc{JAwkLKd!(OjH7 zYQ)LMxj6Z_yuy4(yx@GdJ!-_s$K^SUIC;@VoP1nfr4c7DI-i^#HFMv?W^jF6p2Ucg z7j2Fo51R?-VKcuyY{bdKX4ZSy9BLjmbJD{`oIGrf91mM@@_B>KGUDWg8*%cm5ho8@ zaq@YC&b8v?#anUmd4nD^;^c)Jaq_SgCy!fk@_BIC=3_oP6G( z$Ba06;YOT1Y{kjrR-Am^po^_IdGS`9d~U?a<5rwJZpF#tR-8PZi_?Nqaq?)c6&}sS z$)mYAdDMuLk8^SIae0Nguz10_Qh3yelaI@D7;*BVjX3$Zyhg=2PCjqYSw@_^a3fA0 zHsa)AD^5Od(79Heym%{4K5x)tMx4BGBTgQ+;^c8FPCjqY#a5iWcq>jmH{#@RD^4D_ z;^c8FP9D$2X0db;^gC8oP1nf zVJ<9QaIO>{HR9ys@*GB-yl5j%J}$4)h?5tc>xxH>ICLjW~JO zh?9qnICaFnZ?6oRJm}8)fmZ(K8PlJ@c^DGoLr8)OKTRro*Jt}?PAdl5EFWw$w9=CetajRz@ zw|eGrt7jg!2c*ZXo_XBrnaAzX5+zZAH@OjpkK@QMO08pQk}LTGjF6%RWfTsc3}4 zi?{mdb92`5d4timvf{@Zt@F6mC!aT%2v(iE`266|&scF@^W&l(&1Z*4b8+%$KGi*% zi<3w53FFaRoIGm8$;Y`k`M7-dI?DIYh?AeBd=HH{`O)QjW2UVaZ7$t>T;A12oc!qW zDvdaK(MFtnTs~rEx_Z&(sPb`nOU#_~qK!Ct*oc#l%lpKLlNW8o$;aglG~(n%TXFKa z5htHF7-cI?etd&&wBqE)8*%cv5hssZaq_tlC!aSMZ7WWGyb&jlTXFJvgNb0p$&1gA zUj2+!Ax<96XNO1gL)WAERQG5uP9DuCj7M{E@~9CfALruasyY$B2^` zZQk^F*oc#djX3$Z!CWhEi4`X=i+%Iw^9G}A#mSF1;^gxNU0~lr`te4bJZ{Cw=Z)r9 zgVDC)I(IC$h?9?Vaq@Bb?iq3Nqsw>Dh?5^(zKcejyl69ReO%r^GkN^z z@+yrudC^9kd|Y0o5hpL&OjjS5ca;$*FWSsWAD8crIWoOyBTgPR;^bi?PCjlh*UDRB z#mUQJ#mVOlM%jv!A8*9T=MB2RijyC2#L44UoP6GBel-|vD^7kMBTgQ-;^gxN6Tym; z7oX4634ix1)XB&Bl=N|~Pd?5^+{d{>`8c08KF&4D$3~<|c&<_&L9Bw7N!SI^t z>c^LUkOB3Y!`6?tf9dktX|&6aH{w;o8?>|Z698zB)h|C$@pnJ3MfO<@B_$e-nSIbg zNr^_iQTz$fuiVI(pUUc3$%ckAuhA5+QdW}6Xqmskido5qM$^N}8A>>hgy|X?>RB?r zvUnbjdCWqi?Q`rO#Tsp2m4= zY^CgihGk8Em6t8HHR{XaVz6;vEu5s@g{5sa^)@bR>RnV?w%FFF%_etw*+ z;~n10%r)5&P*%FOagw^r8*Ur6Xp-K>hiSG_cjMCLm}yYDwz0J3`9q-05$jd$Y}QDg{`z+``4*P^_t-*ueaFNsBCe&xU^n-v%F#1yj>*o$g z^JTyjv%vtQYgzU+f!-VcRgT0r*r%_c|bd%u}N+ zoej&(Yq({8!z~LMZdurH%c6!`FmD<)8{%HFDSz`&+6(!X(tXXhlb#kRA9|+Fa!1+e<;%T9LNU6oecT!JSuNAY~=SH>fyyD?LMN*A5Mq zF@En|{)FiKJMTuvhDQ2&yYRSFv$VXgdlco&%IV#Mz4%_NB5~~-90M-(5BB!0uWcI~ z8no5dqbkFF{c{)2uZ)Zjj`gqY!(&jfo871|7#{5#?;V8|GMkm{?${Eo2tDoc#E&7U`K?!2IFU0?T_whCI- zjR$7)LBDOq&hq=>i(d4@mY;e4*rLIqvDG6(>ndZVg({WG@(a(oVA==h4!4R{vr+R7DuBcuI8gJ%EGgv$B>r;(MM^p_CxOldn=@OXW6UiSc-x&eLH z&z;^-85rvB?d$c1cU}4LRw^q--45y<9jdIhQ-5oNc*;3T^Va8`yKXi6dpw zPB=hl_jMb9liND^fagqk3%mlHz7a1N?{6(D#ov;KIoN-bXuineRriB-?-I3 zX1lwjZ{z^R0XlL1^BL|_Y7K|eekq0-Tl;Mal?uNRE|RSs%0|#U(JK1RbkF|=+8}i; literal 0 HcmV?d00001 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h index 1868fe1163..2769309496 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h @@ -1,7 +1,6 @@ #ifndef NRLDPC_CN_GEN -#define NRLDPC_DN_GEN - -void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z); +#define NRLDPC_CN_GEN +void nrLDPC_cnProc_BG1_generator(uint16_t Z,int R); #endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.o b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.o new file mode 100644 index 0000000000000000000000000000000000000000..e8edac1ca2bb380d6ab52110f0dfebef52622f87 GIT binary patch literal 117158 zcmeFa2b^6;dGLMCHm&Ne`bw*^>b*;r~*)~Ua;j}Fmg9G7_%;N!Im*GU~nh~ zV{C{k0bGJXm|)W!921C12r+qS0g^z%o1XCf|MT3l_inv+4d3^@zu%kLJ@?F+Gv#UX zoSA2yGv}OJnlr;W>+wTSNFcg7+p%Z)Syx=qGqvwkS9Z*v<(K!Y@U`)IHle*|Uh3Pt{G7|rJ^RY5 z&n@muBl7Fz0b7x_Ia|4B`87T3YvpEZ35SY&o0nhOGv6p~c98F2Xkw5o)VF!X+H~3d z(?M)$pZbp3eEf+gbl&ibtTD?vcRw<>i(H+z@4mmm(|aD~wB`0a=iR>R31TfzrPJ-t zckUiNVQilLl)PEz9lKKIJ2p3W-oC5TazzR??Aja&R@8Zi2^%UCQkj*cocH3c*_=kT z5t&OQGcw=EC>mSY-PrEY$5g~`>yF=%T5kDlcJrQ=o8Jf_076(uY5DBSCBR!AfBvRD zGr#z+jkoVw%Dtzh7k6)eIp34N{KeOXr8^6`^Wv^cZJO}nu4_uMzilS_i@UBXE??s= zjfmeJt#_nsEuX!4t5~#rc2EBN9Vu)6a-!B(x&hriIvZC|ZujU7-SNIP&8b?`1>L20 zkA9*e{?qPwB@s$6KE6u~d%@R%>?UsB6j0xk2#^O3`y^_$+&JbpzxmBg3DNwf=OjyA z%Pl|u@8A3ePEF!!-)mmj)yDbLTu{r_h-7i z&VSi?(@!r-!n9}igc4n9Ma;$;tnPp*Ypt%3EN9JK8qmq5RUqmTkZ+rcnyv8sy+N~h&+)K z`5}?p>WKW9$c}m{U_JpWqc`S&8ve-cTJ z{&$fl1Nzif9g$Q|1Cf-ciO6krWr3_K3FOCm2&Ab43*IkXr5`ko)x%$ca4! zvbkHcJazMzC1cA|L)I)6(sx!_`clmb#vQwpz<==vb)ETFTAsRjYxQQTOI!Wb@9AIK zN|YO#v`MvI()Qin($>&&ixP+=-7lM!wvQ6oW8`B*IuyH)6X`PYFp<}ce3D2Kg-3{_ z%#RUCnV%q%GJlFl%KT{}Df4HE?6BsiiKNWW5=ogqM|7t3*=fzaY|;m*u#= zB*$OwA;+c;EXR(t29V=(`pWU?J>__>9&$XYQn7yVHAF4x*Rpb5_L_}7rF{Q3>h+?s zfYW3j^%^asRh9GmAyJj)stbC<)w}x_^b%=@Cg_s2m!Lo0ThJR@Zh21#`eqQ=S9v;+ z$Tdc`5c#x`gNgjoNGFk{O3z_LE--Qgkt97w5lN+vA(BdMCz47XMqkyPq7BB|6nh@?_? z5=o`*B9cnoO(d22Jt9jhI#oldQ}rCJm^yH$8f3Jxqi?6$(X&(a9IdogcB&YyDB!z` z(L?95%@qIbJJrSIPDPV_I#sls?&{Z0UUUT;gyP7yZ{Nk=*oU*txvUF#3+!^DYwp3CS|>Gcny+X>C(V zciQ95w7ApBosQC-*>Pu1`OX5OJAhzO+*w?{v)nrjuvf;NRpmSDN_WT>VMVboGt>i)@L+Llara+e>7h==~%Z)^f{k(mJ13T(7zN z;XO>QpMYhZPb;ORgr_3`;VdO+^&m&v$|B(_MM7sO$IIObJEGE8%L&({R$i+}xZ7rb zTAA=L3BNQUCZ9-IQ%Uw7?;(4pzAo82sjuvH_LRMj9-805tF`n*R_Hwsi_nL86S_G;~*RZSK(Z6(+h&VLql7PLW>rZ-1S98lP ze~_eWRNLH@`*t3;1Fjwe?Oxb*62BKKLfz>nr}Q&R>7%;S&r0bR73pn7J#S3uS9GV( zE!BTzO24k0zB1Z~J%T@wx0_At5CTXu6+yC{B5w|yY?%v$cxqEv z{SJpzHRM@YQ=T1F+X{#Vho^vgFqn%xzsv^4tDL7}K-??y95VoYdgkfsmxjIbJkbxG z`{sEq@6C(;^0fBiSO0l7_u%P3c`mKs`@ng4j+A6$uskoa6S z59pfB@d=J!k!L=N#1Z((92ao(4z5$(L*DO1{;uJ9R^QOrG^}~}i1DSodE>a|#=5$^ zq_i??sqb}d*5ZDtSThi`&=)PYn>#4rJv7WMnhfUnx3NMe~IGy7* zjz>s)mgAp^FUYg5OQ_@~jz_CiHh5G0-R&Ap8!lKb;Mhp~O&p&g{zByLqRFli#4qHy zB+@E=H+5~!4g~(gyN=GbWhZu>+I41jcGo!-IR=f=dP~=&ti5Yq*Q#s{E#+BL*SrKv zQ4W~0PL6HdJ(c5pjvG1N#qj{?PjP&MBiIw;%Pb#T_%bttrg*8_z1u4!E}vsqmWv&CIYvSnS% zBOk2}hf5Q)9;@C6<)C4JHoBAFUL^!I?W)LfDuv=qaZ`q;_(;xb5>x07{1*8&nAK&9 z&Zu;ELN_4T%_Dwjwv6As6FldoyNk2PukdWnzLoOZeol(o z#yZat{v8Ga&5epFot$U@i&ZeO6YL@MpAHOqDHkEMV`%5N)W#sWtJx}ly}%YdcIHztr<{!i)V|9G@d z@E=#Bs-cD6F8|vp)dmG7@H;gAM{iNH$v-JCHRU10nyR6YeEC0uGQodK*2e!4&`nvF z|I#b?-vae&<^Pn#|5j>fr&RENDs@gGrFsbdw?nm_p)Q-#Ghu)$`M;3T^Gp0+kWGe; zi)!Zoavto#|G7}CgZMHapP6XFqrPfbmhD4(iy0QJ1&SrvY99E*X@3TA&8k{DBwwu| z-A7S!bmIRAu7?kS|H``jAIme*2e#Z^c?$t zE9Kjv-5lUXEj{INFU-htqLH9wl z-3jE!!v9mjVSn1*ksVbd|2rw$lm8CoYvuo`**mi?XumysZ#Vx>ga5YpMk{9jnX|GnYI@E%i~f#9e^a*rM|J~UY)O0<6)x*n)|CeV^XS=g6CH`NVJ(j&=Nc?{l z{y$9ryPH2l!T-1#9EMY~P5H{aBj27Koc|*GyVU|ijr|6P!sR_cET zW^Wl1{U6URL*D9;LHpl(vU8!|H8u9XSF*)A4y+pCinuy_mJ6B18JIF6(se=o~=koXt3|Y)magb&iLf(b=B)yc;FFBc1_~cZ!%J zp|DCs8$uZ|YZrdYIcv04Yc>DSgQM-rk}>lMUiLSJ51KXiJH88t&aObYCcEj&XJTFWkrjDxQ^n!bZDZ47!EZ^DgB~O>8NysJ_&sjvZ=&|_A@o|L@w_X<%tqZ_qWIw8pd1^v$Qe) z%vaiv zs$^YD6{sfu)Ha;_PUT;Wjt(f_O|9E*$uSg9NBh-SZIY&`bi1< zOA)h|h;^ZllzjV@EriX=o+3`RYOUrUdg!hHwL#gh)Q+tjp(V@pMlWkl_e`z4FZ3Y? zWmyQ>kRM8W=zsBu5c)qX?M2Sgtr||+&9wH60gAEEU?MbV>_G zvNoepl$$^c+Bu#7hyFL$Fz$r@A5XcFTow9%9JQ*)#?zh_zR_H3Jq!Imno>gzEcG6I%g$n)eT_wfTxFh#Wjj@k)M9ralqqp0NwQ8>n{c8)>ZQIr})F9N# zuxGWI&silPbe&qpv4Ajymdv>tPMS|?^;T$Kb9*QBzoms=t)d=|5r(==IAiSLs3q3L z%oDmoUJNyirL_9e(T9-BO=+SO)ghnF9M;>yVgD-hzx{qZe_^q;$BstQ?Vn@8MJlLo zl#=M5t>m?ji#IOOZw(tOw?)Ks=o`#_^YNZBYM9o1unE z{l5UpE`bK2|2sI(!KOHe7Ml1i^#3gQwUAu1p``kM7A?1tw=r>XA-_t~3?OO)#yQ-d zM-5swr%+BwokRLusBe3r|K)Bo=|k85OR+hH{$EIq_TNJPFW{#tkD0?wH%c;P?Pr>OS#l$jzoO^x>BOdw~*7i)&JHt z)DZe#{o{Bh^uO(lLvN`2#uE1ltezbYB%_g+(EpRcWH|ESXtIg>-U4AyMtzSO3o^r@eJ5r6+)``o9gSYv7)JR!z`OjoK>J|FgKG47qwSEY&+y`mdw* z9C@Ej+q0>o(EodZjrxB+@Mg&GUbL`?v~fuCA`bQcGD=LOca-)2Qtqrn=GFhJC?EQN z6;MjyxnNhR|7UO|6=M9qK9v|M{5tvUN1@8Krgikc3~eA!*8=IX?n>u!m9bu8*dLlk z=&k?f0_|L2o?E(KX!S*4yMWgA2g9=dxAlxR7C<8%p@tSh|L>Qcna3gnCuSR1M;QfG zkKnBSKN|O?CVuyaPmcdX|8L+<=>H>;>Mi6||F1@u90V6zvcup*rT$+B#Oii?7Aa-sisWSfz$!{MDPmg@hL zfH3s`Ceq%({X?_U!EAnZHb*;tL(@oo1NSCmr*NEx7oCRhK@U-*i}&OL}1tgcZRX*)|CsD*aOti8 z&*08M=>MaUp0ijTJ0JJ8iz#&gd^?A~-$wtdQ`BqDAZ7wx9lvG$KN+aT!0%=bEnUts zTfsQ=zjxLD)1j-gkjY569u#H$@AJ;tn7L+f$5myYb}^n%%c(PLKk6D9^>yoO<8LzO zLjTW!(;Z06A`bO`2dytkx=sw{kvH`J3gmef{cbA#bOt#_!>4JKs0V{_z!e@PG5%jd ziu&JK+d_KI40>=Y`5hy<_8$7bjXOgPG5#;~|Nh93`hNwj9YU>#As>eU&uS!M2GX|}i2Lh+=qPfk{|^Lyd-QtX-V6nna&J5uVG3I9AZnb>ojSD5 zEbge?CNi2(4?7+lT3AP)%diXYD52@1P2QJ ze+kl~{y&2nKgxRWrN~S%{$GcFx{Pvrp-CTt-*chQv9z}rI#m6?gTIG3h8oJ_|7!aG zF5tf{>Hq8D{QHrfuOL(E{|CVD#_VQr+XMU;0r%UG#3t5YA7)+uh3rk)T|j+Tb`$b7 zjnvTp&m--pWxt<2ll1@R!0q+v|7Ym0575Vcitm8>|HbSh*-wzqYfJk73-qkFL(QAg zQ{qKmc4tZu0`)3L+dAV-bQO>{l6BjOd;(JN&g=OwEH3VM^Iu7dgnm;%b`iD zsQ>qdbK~e2h5p};o;?NGJ0t1;!@BiJ>E zvkU%C=1@=HmVF3(D)s*^df$iW!B-(02QmV=vqJx0N8dO*`v7+e{ja}6=>N9?a_Il_ zkfou9LjV6B`ein9y9fW7?fiZp-Q)QGPm=!sdiL?`3Ht0v`su3dPdT2=9z`#y|Nk6( zeCj@oH2+!lT_orgdhOoyqDuXL3$%VWei7T~EthlWt@PI!_(;5$exd%q9PRTFS{!QV zqzAo3A$CzB+?|SlnSS!M0NW zKWI@xoCxQ`wk&=;Qykd|Wm;-&f}{T>bwgdgh;| z5yiS}UVa&#ErtI7GdLXje^mZCUSes@Tl0tbO^6QRM-4tXJyB0Ux1T|Otb@b-=^uTX zE>5F?OOyWDiZu7sKUXrMUWdG0gZ?=r>7Szq)j!vQ!Ax}NHNPYM^I_<{}&@B_0Rr!p?_NP&_AC-PwvUCqxaY6`{tp4e#Z0SR;2&CY5X}o zzaQCqnKsYMdcWdTU63}T)g~jSUD*lr*)y`gO7im&WaT0H*h6U1J9v)X1J(X1dk`r< z6q;WOh7U0gxG>#)6v}>(=kO=9E73)tN%Hdu8ekD4sBa=adS~51T@RpL-M5UzZMlE$_L=6L*U{#eHk( z8?^YD(^ZTjt{tLSi?8Qi_%K9^)?hmZ*G(;J9#hQMJ2a$(xMMzZxf<0(%r&vFaA<`K zUxSn-r3Xa%Ce3<48Z@C*f<5x2bphqxap-Zcbt5ikE1{uz3tG*g2% z->~v%>vYvjf3JYBSlM$mO?+(4JFaHF@~Ure1yrtBwpb0--y--L(kd4$8_-!#)FcfpE9Fe-PyS;)%=H7;PtC1wh}`Zi z|E{8%%RechPr*ozkbhxtU7>f-M_!whZw@LWo?V?VRhji{P|93M4S2lo9aDO!&kD`h7k+C}bLeYeA9Q6v zx$|sUSKrkdp#iPcTp|Bz3rmFjYmx0+|9I{zJwj$&Xj~zeugaGCMmZEW*SOfwBVD;p zBOI1>-ON_|lYdvUtwrv)arpM?RQ{SsclExNvU1qA+fuHH)T;dJ^D>2FEO*DHHuQn% z9YQKX{--f6Q~sw@L&(4D*s(g{dqN@q%3!hP9P%GhIf@*8gYxgX*Ag(C!N^t%aWg5C z5-!^0^<(i}71w%v8`l*oE$(g5sf}^iRBF&ZJYxX)pNj>cEdNWG8@WcS{JT1&G-(}G z{+BXNFXZ1g%(n~qdI1pvw?9rXlv=1lTsQ} zd>rHC)T{%D3+7$vKbw)5xj(yQ11VxPq<6L^E^#HV#+R_TsOJ z^zm4QTH#s;f7;U5rd-PZOzL0GtV8+NKOp4ab@Se#g}R~#ugW$9i}HU!N&c5JD=FlE zId!b&Y6bbr^1m7mXC}JL&7ecw3VHLrLpj{?{_=J(XID@y`<0tBxtj{|V4J$2v9x%hvwTcn45~{BI#o zA^%4u`9G0dXV7}@a1L{WP5k+W+>y}v0FFz^c``HIMS|EPe{mwIzL}{OiRwiPW)3iSn=4+9-aN&~`Yi{7;~M{b3x^qmfVFLOci=3He_L<@B^z!}UV=9`e72yfcudB}xAGO`Kko71{G+RFbsk+f}CF2<0q{J*K67JAG7J=p7? z?w0?z!T0+q`4AR0<^K!F%3F||E#xWW|Fg9CZtl!r&fZu4zXt`M;!jJ(my!Kvn8RPn z9QtBx0B^yfejoGwi?Hi`IQu%Ob)+;Kk~0e8wQW} zMbbASDI4JNT;Ly0-i=BASJC%E{`FYeh%71po1keul=NLo<-dc!CE(CIDF0iK|5a!S z<$oJe(Sn4A{@)+T*htz*wAgN9-;8}H8`y)_Mk? zT7~>vi)3Dt531((GTM$H%aC9m)!V^trd2KHr5tzo38HzkVMZ@(Scj`rHS1@5x?6kNg4l&E8>S zjtu}++82anEd# zk_uG$DJ(eJ5ey9+h0Q7@kRFiw>r5tKDN-ZPz`xF~ghuO+bqlX?%X=qmWL}5$%3Q`A zW!Dm%5gHsH3!zVlpsq7f=bw?oI<3(*#ngFZEx{RPP~Os7E3}?8rqlvLX{b#gg19)I z4|-N>!|}b|@_L=?RTGx9m}gjzhoL@=4a7`ucgO#MclG-9op;9K{2(lB&PlW=h0RTx zIIGb*BLuz+qP?fUu6hfFEGmg&?R?C5K?AQNC1yhAD(+RQUAYLmLe#B{D}_QGErq;< z<)g5H$+3bTgSTL9+6Fx=;~Y=f(B@zW+ISA?$!T$uVzmVMR>;40E3He)zYm&dY+DY;Tp>F-v$IzXw$i1 z^)Qz4SIGa=L~%<`r>#Q%twqnsR_av#Cvo35g^D>#wHCrME7he+^h&v`ZB3h&!E0qo zIgl#mQt#Cg?2A%6`j)g&V&m;t?df6r(o&{1QVCPKYM1{}(0MpGhx}`K(2DDuFWM@! z%7ktR`S)Ee-!OA7U7LJLf8TS_BXbHhEC2GijhcO9#hsugC;6XBd&cy{8^hhOVO68i z6vocVzw<=xA0hwKn2&`1FXUg3LEqZwp!JE2Ykk|QmY`*9PAb{LJaiF|ErbT`P)7Nm z1r_wG)SE{6w}k~@)B#kr!M}(yA^&=BPhdTDI%A(!4(*9O<$nz{)v8rJjAeAL z{4b!6nP5^W{|kXro5>vJ63!*(_mF>QKGj2LH$C!QrHK^)Y2FC@ITSKz3se5pINHk0 zH8lBmuPXI{cA`T5_5Ytp&F(6u#Jew#^6y(W`urFAD1k8GkMchq%(Z$-iAwp`F6TQh z6FK|Fp0*A5L2~!0p~(LX+R)2?9ndNND}mR&sKzs24EbLK1bR5HLBf_ZvK_>zS4sZY zBfnc1K`%f~GdvhHST;k zT$}tK$sFOpZuvhW$^XgJ(7?>$9H_FBnf)0_{;#0zPOupVhR4uKZSp@2NPMa)|H_F^ zD}A1Qe&xgrGgFFBICW<;oL2tBCYCY`@}vHr4z3~piz)4@jvmVTKQBZ67ZRI6>I#lR z{@veg`XIHIZz=y<;nr4a&anRMgGN|^)C`Bi`w~AKZtusrEdNJf57KLDO}UamVq>vT zDF3HG(RIxHH_^@o(7p{0kB0-w|Iy5>=95qPKNDQfhd)c;el0=yH|JDnQ7QlDFk4&z zZQh#X|6Z>dUskjuGUkp7ukoE=L^54O= zTvtEnQ}1qod&84?HOi0jePhwZgvB^A3{61>>b@pG_b)L>f=J!H%<^N~d z-*ayZ)|Ic~D>YR4e*&of3+vs1`DyuU=>NO$b8Nw@=qDxl*Ms>9DE|bU9+}rJ|EEF8 z4!BvCpB*LnISLEhOzw4H>k0X}2uuzK6XoaJ8tFfroJRt!@^cT=QGTw2Cy!x8ABUau z5?Vf)K6n;fSdCq2J@&kh4pDx71pGgu{~p60!%Onn`8VP1Cwk~l<>w>V{{Ik;9D&Vo zE%w9O^yl}0?0#%j(&s&?f9*gQJVgKclSH5UOZ0gN41ZQZpC8dyEuo;#ub|Jd`Lo#H z>au|1i$x_@%x*dzdc`_otjIZvvT{_=)9KtwOE8@CSsN;Qi}3ELBn34 z%^8>o)z#NU~^!MVTh^t(eztPhK$kiTONF3jFnKSV>BOzrD66{>#ur>v?7b{xh-;axCLm!66*s6%cgS>tPJg zY8@%#@9fw&@LWyhE9TsrM5(|q@OQpB0w@Cic5*C8wY%EBHsS9G(0yUY(Ed1JUc}tg zungFIC(eD-40 z-^@s8J5PW&mgN5#H1;_>o7)%#ivKrx{(OY7WoK!vst#QLAmM)t>p?j>^L>n{9^@$F zzZ7WP8OAq&#eW~Dv!)yWm81m!4~B}X(mSim8FL5!kEP9J{1g83xNe4W!v8sNyNi{-D^hvkpPLK+ z?0kQGmA}dg)yRAaZy>bgW_XGEe?k4vQ~ysG_e_J!Z^c)-sQ*j!zRLQ4mFhn#FX}Iz z6Kc>RZpG!R1jc|rp^?iay-t9o66M%H6~t3TeWtxh{o)ZiUR_)*g#EB=D_6T%S{jM^gJXSaK)va!$j;CsHP5Q_4ReIL8!eGh5Z!!26oK!QFM;T-qAOxl2 zc^1!V`R~)rr$q6T9-uJEu0BX_q4mkGWx(->v|Cc6Qmbcm{yU}#{<{y7 zV-r^+#zI4PUJ4yM7!b{Aw4=3L@8hYI)nCeyko~{94aoOX%;kIgBPp$QJNQ2ttz5ml zw0Csk`=G0#+)AE@@_#;(xu7QgyWd0bUrSa8W!m{&%P|!G$3A#+((%<8%DN*#^p3&k z=d)KYT{V|`tW4mnWncc)#((!eXrRnojwYaXUzhe&ehxKM3+_UqH6({_6M1?LgL`Wd z|JPBg*7?ChPyX-E*kTzq?3?&Mmk~>~FawLgp=3I+#Q)=Hb^lCHOZo4e!9&6SeG>oI z!T&Q${NERkrmce)=B_?@!T%E&XPwLFXDp-8)8PMU(DV4J<=q`hZ_R1scCFI6jQpR@ zpPHyzaI8NTsn4NW3w-bm=z{;Vm|!(k=LZ zF7;f9rQ>Aye<+Z@iCQnJTK*U$&H2_8-V{3pzpmi_%}~Yt399q|YHW>%V!OBxzrVAw zhCBk@-^&>GV)%bU^1B)wgo6JM;9;Xr+DgWq(f>aN{~sN^Fn3?XQWE_C6ZrpEiT~f^ zJ>lU0OI6FSN6Sn~fcViLyLg-Q8NzTfs!^v40ro&x^=%2wpU|APVKr##!}OI}Bh5u8PougY*Zs)-tW!uOtG z_yjaf{~c=xD^R&~#KNnk?6Xw9?^wiI9Y=W-&=fhe2Zaxk_8P54J%bqe9$oAg*Z&i^ zu!M<4@A|b>751_I@Q=IkrjKg_eerkP?D#w85(DF}Z^M|Lz;oqzEb#Z6J$>=_%`EYE z?b)$bU;MR)jphm9YH@$~3!UT3!rIppgz&v^^r;QfSyj*A7{zh2?`w&FZw&NwrcpPnue_WUIEKK7U`5*ZA)}Z3ASMbs_*Pqi5{*Ggophd-h7URI)p^U%w z$lfFD*j?Arm-vq#0RNfbKLgF%*yjm7i|0WD&t2a-ssqYdy_(;PYyG#U^5hkNuPeiG zXzfWn#a4p9YoS{zZxY{9!hZ)(%X6_e_2&P6Ji{lVQ^X&C**^HU0-d}6$$#fZVTCI< z;*LCy9Q`x=DfmmF22a>@&2zJNs*_Jn!P!{{BAruPos|A1*9|Pkr$} zmQiEie+*BQ-uT_hGvY?@zYR;?n;0M7*Q@=&|GW5O2mW8}bzl7dvm5^(_rd?PT>fuh zjZ6OTjhA=NaA|`7SS((1Y5y|DTs^}Tth+o|g8vEN|76eGctQ*RPuO2!Co3rbyAS+P z|F@|BW7PkvKJ~B3i~3*7F3tPa->bROrJ6SWif4y<+M~EGVv%0X9qEy`xL1@Z*I1N} zJ4M~S&ryqc%b{F{F|9XoHb*=G%dM#kz3*>1HLlBg(r1c)<|uN)(~$TTW?XP);V#r9jWA>Yk#&O?ZT_m5{??ALvXsV{AmppFRfHQ z>!g?#qoB0VcmxHAq$|&r!Ie3wtgo%SaBO1;l})_97B=b&qT=F4})?%PXag4@X*%M!>ALApb9T>zfH@idV0{Lb=p%Kg_h93TgtO$*H zNvKnQFek zOk1;M3LL#w5<_y-0+xv05UoY6A+3Qg8B%MW%fT9zBI{7{q6fyhav`~{duu(_b{TCc zvj%%h*i(fydT`iV?LXEX{i@J^rUqw&qfw925tNHxvUCT>kiHQiPt+_*jqAb2?bAXX zU&{!32(xk}yxQwrySJ^F_efvuG0LGme>7+1%x_D$Dj^+%2V&t~+V-fy^q*tA!S$d1 z`}X0`fA*sIwyt`jQvdlrZCU@h@3s4Phi8AK{u@P$QeG?zJydYEFa7MDh5nNs_S6>2 zsW05SpwNHOTctz1p)9BL!1ew0(0}g29q+s=E%sn(Xqu}N=A6ityMp^JN~~+U5*{2G zh`(BM5TjXojNJ4&%@HjXiz1>4`XQG~wn*&a{7s4M!c>ulB$+NMAFid6*Xie>#5IwO2s z^g4~*8{Ajhy%=2UFZ7>1C}5FBu1ds?Aik-f2J*QkKWs;Ml{|Zv5c%y3`-lEG1M#<= zJL*5Z;O%9h|9sOzU-{SvMvdTiL-dRH%^Ix-h5l2rT=~%RXAF79Bcb-Mcq_#375fbj zVN_nNL2A3R_;@7JFLVg66fneZik5zS=RoPvD_`%H82{Nr8&X;Ifa^zUKi{O7&Tpar z+G!~;4;#1keYqzVJ@udKUP@c+Vo~TncgRGnk_*IWx#Bq;qI-9&z^|pAVih zfy*@p*VJ;X4eo-nkhW%!H}s$Tp89TumWSAz-~D&oX~R8@O`8W+3n{JFifckMlSH_m z@~p&PYaa+cwVAv4I9{4ZoA&mJP)2<;CFp1yaecVub$F58d^+)tocd7v}Km zZa?ZpDX`FFa#!lVnfOH&`fq-^-``IQ^I*q#E3ilu`fpkCs9FS`e)+qZJNSEK9oR&g zuwLk|egTuQhLjQd_M<7yan2{F4D4oE-W zaa6*US^Hu<6MZi(_7hjPs5|_!lzmYD{Lp`nEc`l;`PA2;16>_*g~{F;`cFT9pThB8 zreD199X{(<-{=YF`{?m_cI5iadZy~KrrL;BpRTjS}Gae~)_n?egd_Tj`7ruk2 zYccuvqOAJQos-pci;?L4z^qdL?ajLFbgXuDz^~`tCLmmzXk6&Ojnrh%o(sPn|9R!u zrKkS0be?+TB5G0p%^eWF8TenV23NnhW6$#&5A%rYLtoZ^YsjVkI|_?d=)c1#wI4O- zl$e3n-Qna|z#9vGuUY-KjvCZ|$C5UW6~=`?qW(LYw8NpC-|P8p_1_WH72|+v`tMls zxgK5UzZ1DG>%Zf%mKxk?Kg%`)pFOaw{|*G!fr7i1Y=vfTWVNo)e-|eGcP=&f-HB%I zEP)QEvBG*_N&oG@O1goR91Eu7za8Y-imi1LZM(~l`tNw`%PUw-SO4jQc_O(wum`ID zuAux5coF(^^SxQUbteGZG>!?t?7K>SmqvTCJ3iTK;!8Tp*qD@0 z-`N;%hW^t7RsH8^LH(ySKEBUYPfookS}4~}x=)@MKS;s8{bM}&)CrzPARmq>d>YN- za6d3LjQY>_<)=P|zr{$o`cHqB_4K7fsH1^8oCo;+&U&u=3e*y= zX0T$sADH&ke@BAne)OcH;kf#5%Ygj7gq&w!QrC9PWPJQic>TV!)Z`Q5Ve}0?B9kbPcS7HTMgLOjN zdPWde5IYQtoD7$bPd=vVzq7!po;wpcM)7q3zbf%&de~*uB77GQNWZJWZZ*B^>ZJcp z=go>8N&nr)y887{V@UjcV!1Hs0m|NNf7 z1SDw~DP{e)PwLfv3&GW?W+YoZIf=ZEEZmE385%G2->j1Un+3)7`B?`y=a6$Wdf9Ky z>;vu9f2N1#i{DC0`qh@vP|36Y_kLqY{b#>g3e}FM?#;lc{yPB3)qjUWJNKsB4D{;1 zO=1O71=;pe@MKGMm0 z;Zh{|Sa5XwcMdv6{kNN5_2H}o_^up8|NS-jzKPF~`tR#W|J@7CA58l1iKPGDOg~Zo zeUP`ml;d4V|GfmQ-;XrB%6n8#^4?eIzi;z~r26k3cs!gPs?>jKh#j=@JbP9h#xXN_ zN?pKyLVw+@|2{Mz{l0~?*Rc=M3-pPHSQGsmrM`zAd6tKv`tL8Z`*|BL^xxN#{`(qU zKVQbDr&9lY6gYe8zrV#t>qqFnyU{lpyA_=Q%&&s?tN3&IW|sQzD^RtO_|FE>fAjMr z`6__=?+3_7=)Z5n-NSeXV0k{7ciBeeh5j4Py8-`%ca8e*-;t=lgNN$B`T0Nd?%02! z|4zog|ERRGxel0Sc1=UkFk%}MZ5uO|6Rbas_y~N)yB>w($;_qGb zsxLv?AK<|?nLhsmu>3rI{C_9@{)Tr>ex3aTu>J?Usm9+m`4QxwkgK2ny`-NzLFTf& zgPq~V^G40x^kny;J3N=a`{jq@eTHo#FZjD4--IXK*zAP-2G;%0&A$s>kB6@E_s`(( zSx|9h{*Q^jOY=`t&o8r<{IL8|+Fih&bMp7xd?5Nk-coQSC`Q;3E7Au)*QGM?Yx%-n zJb0<{T}wu(upQTPrCsFp1V=ex>o-k5pa#~TfAG;P5)T*rp*Rq9Idv`tY#uTru ztfQ!ax>$b-d$#tPT7wwJnyyy6cmpS>T5AnOzVHJOp4#cB{XSN_Tobbf?P1cOwxHe4 zRam*;DtOSpcKj`?rA*sYyk{!~w4BuzT)Wna9&2=A?RO2Q_8=bHn{fMYf73bh5_ zH+5}WySp~OfTMQ&m3YT++QsFBn7FR^dV<_@I3rci-V20Si9L3$PYYkdf7PBHWoiU$#{j@T3*!Okve=WUeHU0mvA@Kh!Ms=GL|Bs~q zpTY>gojGrBuhoIES;aW2opEvS|8)4T-K=*0AC7fnGc?~uzgfyi(ytaSXDn80IGq`Y z{J)4f#p~mL7yRGFX!}e?tik^~ek=ap2mcw9))<2ScQERH2)op6>FxG+50U@pGmE$X z7ySR^5cvN!=DH8V|0|d&UC$i*i*WNferpY@7~{+Tds6>Dof+PKyhUC+|G!k?|5uqw z$^Xv`k^kS%epurFU&6f)VDnP{Yj>+H?3MlB&3{Mg<(W&&UxIQ)YUD7jnAa3#Johe9 zPAhUpj&d!j&=7ts>3Gcg{3~V`&Xmfn6>%$$T*k~(l=RBdMVj}E+KSR~j#|B6Jviej zW?r`Cb+l0SM~rqNU%(UbO6a4kGayR`Tmfy==?tk{x4D0}L0H5i{;c2iCDX#^F4mg@ zw}|U8Vs7&m_&Ap`Z73mTjkaftw&v_9e2M~sph~&s;BT}YewL=h4AR+Wq*;gFQq~r~ z!f7q$tu*`DdO z24~EAU^$14nXF!F1)iol7jTYkzQ`lA1tbM#QNr1$Ib#m*uTYy-v=BaUrq&j0Rjiy} ziLtzKh8r-6zio(xt(sfx!>>*6BU6OdGLhGqGaPeA4|nz!wdk!RHHO0BTJaEaeR1Qx zFg=WHKjz=w3GaDnY??TWhj>T-5Etk8`ta61zmNS5q=YytQTo_PEoI9T=gv~oIkOf3 z+Z2Co0a8h5f`=iyT1WyWVGDjc>-9?9L4RR$uM}7Q;#cTR^PNkvFu&%0}h z9&Y-2`d+DiaJJbF5fAwOTXHyV$WG^K59{WzFuj+d;Mpt%8!1edRyyP z7Wz-WxUfFyuPvUwH|n?3^sMtci0TAm(r!Fwee`M#?gyfbyZc@E&+3h>@26h0(sW{i zL%EYWq5qtJOyHgpH=bBo{|R5QL!Ger9Y(!#h1#9Zh0eOw91Cw)}jC8rQbmFn@?&? zZJNWtkfB0)hg~;El%R%_uZ6WWw+MgUi~v^OUtLbPP?9}pSbN$;o9%OssHq+ z4*e&8EA^l6s@pRw^`CD*PXWuIR-yl9(t3|bbs;vLo z$TfzP*)hYbcU$HH#XO)1{WqJGS>zrDJnFysiFWFo$%!YmLAV$k#dQ%i=*{gnOZ_6G z`p;eS{jQ{6QkV?Ylrd@7ObKO3Z+=Topp-oHJr}=6*+5P1aJh(cq5q}>rT%j2zxmWq zYY?IZw6GYN(v#3#GABWaiL^5vSoJhl|4k*;-O~Lo}mQeFHfnp>%S#fs0;nK5a=9Vg#KHEtawa;XLFE8zvk9JdlR?{ z{inB{oG$A>xiE!8GP+SPMO4!Kw5N-TLTP+|_y z&7&=Mo%cJQtLQhO|MchUAg}sw7XAtD{xzEX%lKQ!^IphPUdGUwMT)qndWn5S^P7>bRf_6b0z^t+Gi3fh_t?+X3541Dy2wx8-(J&JrY z;Hdg<4LoVZ-nyK6*Ymp!{`f{gtziw^+(a#9{kNR9R|E5S;8p*vpsLV+dZ78;nnggp zgtpy9LrGl-e(qIa$}r;Y!@HW&>OZ~MOWh5kF3 z7Jm2oZv#-wVr^m^KImJ(=5XL$4lUJneo?c~e@8+see;`Gg;4(;#q|te8%-?6e|wXA zeXZ=pb7&njS;d-!`cDt-DcNSY9s19Gy7W0+3WW>(w*qN9iWK$Vp_E)i{sV!ciPBAY z1RaWOsQ)%n=R*9B_Tz6asCXD&FQNaogH^4elbRM#^C|R&BdBQv5FboUTcOI4z3H1cpSO4jse-iXqk9>vx+rZgxEAC5bza$6?! zpSy3Yr8f27Nx-@f@^CWv9!~D9{BEilzLU@i>c1_Vn^=WW|6Ra(!Xa?v)TICL(1A|s zzYA%rtp848*S$)%LgQm;OZ}&JXKi6R zJ*?1wSFyU$NZHVTn~|T;e@6j9=)W_8`8eK17!9Aw`tL$~#ngXtb6>FNr0<^sF6zHa zlK#7r^(*z?Mcmy=o}IM;N3KHuod)HnB7u{^@GREP%KGmTa^+CtblO@$PnbX(i-B<@ zv{L`s3+9u)6uzAc-Ooe+9beLa+kqtX-y6wU=)Y^AL#-k7-yKM>KKZA@=NVwxfe)(s zPrvIoLx<3RZ^?FWZyG*whqE5F7?=4W^QEKR7eQPIBY{ozGLil$*@LY;y>&F=SPk;Ga>6w0E z^x~xdZii0q0~Yn)2RM$!-!SywyQp&^UXT0nU4y&mD<8$1`v%~*o=4XlkD()FMl^9laBx1SJHnUAV=uGhoSd% z^z?D;=JR><(gQ=*e~*FLPQEd${<{qM-bo!_hF2b+VYTxM=s&%XFUE)YI`qg}Xz3&A zTON;c?;-vkC8uTdbzOyo-APTCck90gz~hV5^oQhrl;4MH?H>3d-b0Vo!#ebzSijmw z|6P;xpPq}Y$j<~MelH~N&yxQ8D&D7$qyIir(tqzu`tJi!csKpy7G(2_;9J&z_YG11 zJpo1LBYO+L{qIZq?+=0bX|%+r=%o+Q57$ADPe8TrvKo9GeypMY?uOEJ$m0*X_1~Z4 zKl=mp-v`;Jz0iL*f|L4hH(03uo+HnXYo^~HBD;?Nd_SSA|Naqax(7+Qlm74z)O7>C zX=-_jCMs)qfxB)_?B2^&|A(kAeEz=)Y%>#aF<%84Nzo8xQKg`_lODfAn9B z|Nck+WytdX+4|3QgyPR}K>XRg^3=!tjacQ`T(t$)P_(p}-?PD#h{w5zr<*Bn0Y{Xx zj)8(J8pWUW6f3XBE#+EswCy^CZF?OnfX0i1XpJGDw>H->3_|JZhHaMDj{^c>b4_8O z5No~GV7@Yaw64Y)cdY)pniqK5M)7Cd_Qj(Apxw*+u2;p{nvlDGWgVsj+}3WYSh)%p zREsrBYZxdLwD;_agf>j;wnf)CUCD8^Ce|Mc`iG^{R)YQm(?^S`^|>kZQ8PjvLa}1*9~0J5-#x(ld#^pejqIaBP~~se+Py?XlnbyBL?x! z=#UC)ax4{o*#WDoi`v^=KauXSPD`ZU(7n3&`K+@wqw`Z$qjq;)kT$NUSi`{Z%g0zR6LM$JuCBy-Lab&h@8)ntFIFvLRaEPVs}9;5 z2ku|m{>0avDcqqV{Ip&5jD3l;t_y9*zu3u9Y3IA!aV<9n3d)Q3UAJ&$(D#30zY13Z zV(m=chWtyN*eS!+Qn3x0s@-2)i>9_HN7L?k;SL$Dq$&T}R9y8`s><^33Z6dg{RemM zSL$QU+5K#lf4^$w8i=cr?kMY8oD^}bM0xS+7OoVz=3t8h_uoSP#{=gW>T>niFBrQ+ z%y7ovv9pf**|?SxG%MuaZ(+1@#~rc;3a)s?zFV%?xdvFszin7vd#=0ljHL?Y-_@^r zW~CwjuBKFzf1%P&=DMZ3>x@YARQE78MQ?xis8arY57uvaxyOf+RbBqwBVZaeO`GJk&ANFQ_U{C?BIHEgBH)kx)kQfgb=`VS%hu8WRj=I&aH-tx-7UmTl8 zeR{0>hIp($k0UN$Ceqpr>h{_dyMe+K;BkMQIn+4{OJB(U47d=ybng?_F{F??@%TNk z4q)(IRaYF9f8Q#uJ%s#s0NDa+(b_eVvAuhOjAgbkow}8OC3Y%QboF#_`FE!SzuhsL z5_6eR%fTf{{@oR1KJ)L9%#wV!pi=%_DP2Gr*TzOuexM+h9Z`vtpHHSP<$onLt;BZJhTTQ^UqpLr!C(P=vBjyhI8Z3$ ze+_)tAH0?Sjldl8@4gg%pI7;x56_!{q5~edOSC&gFXY-UzYQk;zTw`$ywg3e52n8O zp0M9%bzhum)T8__rS-kJI)I}C9<*hf!ASYno_z2?;P;bW$p7A018eUwp??=l)?RJj6Y5yQvY61e^*Y7`UFUkL@ zoHt@uIv6?Hrb-Ej&Q zjza#==$8LZxVW<<|EFWAITS1121+RxXD0dIJW%z>K*;}gB<+YK|5sDSRf00UB>6uF{;k0>+JH@OBNn1J(ZAOqF@^qrXOjP02CV)9%A5*a zMk0Z?B>BG!`G1_WcVYWg{vUZ_%6y16e{KaL&)&z!JUr`D*uo5k^lEX`^)H09|9Nk|IDe7 zt^DKv$p8P*@~`#5znE{9&&FyA<_n9FHTYLpd5l#L&Mc$-!ak%G%hXy*7xjmoD17(> z2WP$3R4tgV48Jy`0)FSA)r0l{Jso2v9~L<6H!-)bUS11}_y-(X#hkqqmZ0k8!!J8# zV2;0>aXXuIc2+wDZ9jZ|wY6AV`21CGKkS6IXnT6P3X!(9f#4P|Fwt2+_hQ_T9(3}IKB*| zzo-1yr?-~&ga3Z-Q_F)stp)!bSyvCi|H&o(>piQD!hMx%v<_q?Vib5~%*N zwejDbw}bzFNmL(M=MwFt*22GG1G@p#L&v z7~`pFzhw2;Ozfx{iXRP^Rx-aiu!8>wk>(t-7B3I^uh-LQ%ngJ8$G`(UVos`=|NA8V z9|hL#J~=JhjQs5nHQZaSS~wIbJ-@{Nz3DR-;)Ssj$=}Avduz4A+|SXpCm<`GP(c2l z2;2?nTpR!04@*DXbD;f!75qOR{$E)``+9qw$vXdutkUawHHR6I`??*%xW9J(-^56M z8RPl0@$K17YzH)a_mKF1AM>Z^|L5aJG8F#bP~!iyctf2-|Cj&g!T+b3TT~CX(fc3h z=Kl+nxtY1n8*AqOGwiZYSb&{9OZmD(U?yZX>nzG%v5^b z_iiy$alG8Oyybk77l&iasLeY?ZI0ip-#LTN6wdyzS;Yhe#-Z6R1r{cZaSWzqAchv3k)^V8d`9@+T{MH#` zEZ0B_T9wN?+VUMFN3ibT6l-#22wbgmgzFljc5K%{9iJ98Sf}_~OT0nmdSY=`$i-hP zycRd-HvQr6`kZTH{p0V-rE3R{N?f0-tUvH~{m6HI#xQpA-Jx>(`uqAFdiR+URz12Z z%lo$BRB~9(udMXOe+nfE{2g0P1|Q!ZDq3(|&6dUAbt2!as;s}B5>pvTjOE^(68_`6 zOH)xAC063^+b~7#ext#;%-jo4%v9zBQW zvU|9%?=CHb6F3IOe+&4o=a~}x-=3hY#Q&%g{s+T_1Icv=v^b)o{=k19p6@Gw?P$g+ zJ@N0P#+@bnw{rgsEQyspa0;HEBYCbIg7g*mU)lrzZP>~#r_BQYOR+E))KUJ=fG!t7 zqtn2DCwAydu$z|e2mYs1i3omjoc^Mri@{2$Do!p3-W5B_xGueuYDWc{u`gZF1|{NDxsH}$~(_pv=! z@;~tZMhXAtuqVD$(fIlB+2)zZe)zdonpiPwLra%$K$TpJgI@WQgRS3*!wwOpcS%x8tq zC2dmSm0{~zcH&vuGk4!B;nk`X@CuFo4e>0l#YW|mH=fF3?-R_kQ2Au4Zeh~PCTtu& zJ zJ0bW*t!hD!9d|y6{v-cw)%8N_s7`<1AD_rGO79ovioQv%g-lDGztw_c7QM7=(!GHZ1T2o!s_~+N=d`C_G zw}XNFp9}`_UrJOfAN-$6EqdR`f8Paj1f^F`_26CszU$k;uX|-Gxqb)3Z#vb+|M?~U z+ve2Q$^XS*yqK03B>vA!vD*0Wh-)s-Px-$TO3s9eOTc9j*w<5MwcxjR+8I;H|JCq+ zI?wUo|D2lmuQ$rl#Q(XRgZ~|j`1Ht_316%6Zxa3sdtpRHNTUT3?#rl>Y~o_`i|( zI>wdDs}%>@b=YCt|NVr-_4TC4|6@5X+r_t&Hs}a@zu`%Hz)pYVr1A(xgClBN7Mi1|KT(>n;{S2ra~ATjHS2=^M-NgmZru+5_43HD zNoB0BpF|(XSY00){~v?@kAdmiks0}aGT&txi=FO5>KQz=vnS?U*6ml~F%bNJD_?%N znl*U)|FeS^=59~^UqZRBm-zn$-ZQ$tYWa1P@V&V!fZ_vC;tGzhB>sN@S=>eW!TEO= z?;kw|woi5Q|HJhE7Zd**6Ad~-NIOqr*Ndwzhk-SwBmPvy9< zqAikphMb#erZ9Qd-1&=o-s^Ss6|(+5?S6ps*ExTKv;JtCy_*$M8|3$F#JLb%@?0bUj5|@1)J=IQ9^Kp7T36#Nqci3)?-UKM8D~;s9UorSy%& zH*pWzBpOJk_i|4emu}MR8qW6hS2*5GoIG9Ii4QR(ZiAZm5kL;?^7^Lc5rePdcD)P? zU*z}>MW5rmmgA2(ka0~?U7x5eJ~+4n12pyZ4GoRJRFS#s)4=>Wj@!ZeZVse0(Gc1t zxKYoFnuZOl z?^}QNSzvn>Smo<(;swu3JQeP&nWNzGmE^gqlpi_hFW6sUVSPeOqsd_5o3#5a4)~Vs zDdF?Me$E9y#n=0#>%LXfcxt_o(9~2{t^H@neYSH|k zCrw!sE)Qj}h?jX$*HG6qtf6=LM``yl+JA!clbmnjd=BMrCVmU?(~18($3?X98;*Y_ z{s`yCI6uyL6X(sG59BOuZsS-$+1;Gil**g7jJWr?XZ^+f^o-s^y7j+Mx^G?&%G;iK zgu(U`JeJ?XLH<7FFQE+ii~HUAFQdN8IfSKzkMJaXXiIof{la%Jc^Dd}_P26AqI8f} zYd{9oBUGHaZc-|AVICWG7>*1|XMOx9W2AZe3EagKV0lD zOs7AqJN^?m{)=N4*N#(_oiCDp3ddIB>dX6y*BZcS+{DRK+Gh=3pzEjH|2yg)M}dFh z{A;e&q3yu&FU0?ixMT1R4)j~ni|C9rHfB81HJ8I@;N9GtPkcD>F&ye!x;ce#Fy^VOUgPdd)Z_Hb6; zeu=YvoFk1n|C;lsIetJIb>T{%b^Q(J|IY$A8%n3{bCF_tL-R-nrQ;{Gm4@YW=cO{0 zKf8h3=fEFuzL)d+Ig7WreSkx}KF(P^C4Eoi3{8_BC60N;E$xDyH*!`7m<|uR&gWcv zXh;KV^Q&u0u-k`x#+HqJ1;V5ex>}HlzbEob;=kfxoS#i5t&PKH-5ne}ztXta=k^5d z3*XtKGj8x1p2n-_urxP2lY8jxGp6p0qLH!>UR}#MujF`rp^joaZ5nv&lq)FVRZi$H_A}c4IfwI|k?_=U_;Vc3 za)5gpgDamqh<}UYW#X@JmLAnZ&QoyEkaWh~WOU3->xF< zbnZm}TAq8wRpnWI4s9{{MLlHdn#M7j>xt!aYO}Z=9{Ib<6;eHen}R0XE<)Fjh&jKK z7B_Q97wPj9bwACqo%nH_H?SjeslY-0AB%<+Xr5f>#|Srw|h-Pu1~;s5#RWd^~<+=N}KKj zUAV)a@>t((JN6x3ly&>n%|qre4kr6l=H;);es}v{mQBRB%tLMuS&!^@eCfL787Lm{ z*VkS*(PcaSiTl=0+-EOBHXWQ>fTIu}tcgF5!S^B@n}^~17@SM;p^A%2Cu57}n4{gb zl!vzN=>>l62iuKF_%%%_wU*@V_`Br>B!7=Cx&NHuAAG|#REXgb^Z<8c(KO|L2@gT! z5S0hVJ=`PWTE$q5k{{;(fBjdglmBW%{om3TQP`(19^|+hW*A1%u;Ra^)IX3pCGz}W{MGRLn#`{F5O|9*8nd-ZH+YH4oh z+fu*FE&~VkY1*Y}*w7(^8;1@V`k66f$Bmz`kKBv#m+UmeWxu-m`bMl=#`o#dj0yA~ zG-Sjc`H|)!6OQYC{aRXv3>i9fm^}LJUDwzskIe@T95iT`U3TBgw?|crye29+_$gnK z*7Dj05>TFd$#brTzI__{H1@^g{-(Z7{rchFzkhS{fC2scx3mms88mRx1ZlpWXR=7Y`a z(WkDVu6N&F4ZRwB_wCcv)YPw`si9e((KPqPRty`y>u#eYQe-072MrAkeNohmN3W(M z_Ek?DZg^VMuL*Azlwfx|t)UN|Ej3|Rowa(!l6=>ig@?A!?da@kU$eTiW6r$Rj*~_& zY0Ty2tD|F8+qCH`^5?EvHF@9ssuf-P=GQLoIzZMWi#u0$tzB0unvn1ASlzXBEqr!< zoF6%1d|nJqI+k{?n2C|majQ-{XW_zQd7N4>QnydWhhH)^8JMndjBd)D^~=VeJbKBg z2Q<2Y;TXA$?U0FftdcG4Si53*mz&|Z3Az>gx@{hh&lK3<3p*hgciQP|b(l;8)w+G* z5U$5H)UTg8&h1OTa&F?f*gjeFg(q{B4Gq^Vmu3CQX7cK>sk)P8l{=0LcBtQ<`Sr_= zUAlJNoE7WbeoeckJI`$uW;EXK^vHZ{-~Urv*;M+av^W)|nb;9`ktVvTQnMdyO zaO$hLo2wFeWcB(?-6y4K-`SiWC(V)BBuj{S0C z7bGSxzv@{05Yvy9m&DcN2S_^h$;5u1*sl|NKCyb-ck0-_xTM=wz}Bc8hD&M-6FUZ% zbRC~h?9{~WPwXLF(y>2H?5U(~YhuqP_Euus6Wbe)m2@s+a7p_;+^c3k#U-^ZiEYIt zo!@hby_neO-nFq4a7o9uCN>?HbnNWJ<|KAvVv7^|Mq*dulJ>j4Pi-CF$0fDf6WfeS zx{mu3dnmE~cwDI4I~bRA?5>IJg-beiOk(>aHYc%piJgSQ;R9-8_rN6`J1Vj9xTIqzCpImyg^3-L*oBF0#3k)lkNa8OSAB6wP40Wu zhTxK}WB0`NPVB72zJyCU_QJ$ACUsv=?25#0OYF|Xs)@aZOWN;=!L_+;!6mg{CH5RH z>HJ<@_@yi0BDp}3@D7bMn>OFDK@Vy7gwHnDROyEU;N;*$3J6E2l-hS%qw$1^6~ zYrn@OUHWQbZ{U)y?VZHlP3&-_w~k$aOFH)0#1`R_j$NEsXJQ)?`-j9fCw4C`X+K1E z?tIKtf0U+|aH{4mb~b6*ij_;H1Ye*0J(pWv=N~~WU)nXPQ(gYVf#bg9X&(mSYdpT? zZYGtvxHg}p1J^!J@+DmR0*Sn^CNC0!~MaVBzP%Y zUM39s$PbC%BRK)`F$sQf=3XF3*ZwsKUS16P+=Of6NaS9tK=LB46-nO5wGzo-++USR z_JdSN7C@>b%OUbsgmi`%;aZ90MqDeCJc?@-l0V>@+?Z*fp19URG78u7By(`BL{h}H z%_MS^RY|VLwHB->T~`G%j^q_cf#hvSk>q1YiKGeF$|Q1sdo#%lT)TthNL;&{q!ZU3 zAUPM;9wym@Ymbxs0N1vV$cSwu&*Iv1ByZx{?@8)#@BRmp;gB~-_Jh1layaB&l2ajn zC0Pf_;TxF4&coNGxYnEG23+e$@&K+4B9X@=GN-i9>$tWj$=`5o6v-}lL@|M6AIM}9 zd2}+JL>{FaNYV|NL$VPvpX55oQ6%?5jwg8GN zK=ODMIqh>Sq)2jx^dY%W`jA{Jeef7L?Xy|>ko>FkA$eK)ki0K_@Ng#WGXV1~l8l9v zNe+foNj?Y3w}gFGNgtAnqz}pWqz}ox(g%-w)A>9teMnxDJ|usWJ|si1xAKF+J`*8D zlEWZnl9QzdkDSxBpDBIt=r)y&kSfXdqz@j&rZx9SA3WwvWsCF~7RoEqhvWn4Gd!&6 zkK3w`<-aD+3Bd$0ylo^oxXF@p&QYBd`eMW^fUzR?jL%Blwj0xp7 z=|l3U^cfr0ydZtXh4PN{86Qdmj?*g1UXb#Hux2`>xKAiYLh}2DvPAljd|CQT3~R2G zK9fSZL;CC&%Hz_9$3luzLpekGObbPx z^Hxc|Eq$hkHFry&8KG>EJ~Ko4gY+T!08+qD+R~%0KhD}R$tZ|?Mcl#qzAIFN-_dcm=lhg3@MY$ zgXHFhHH#rdlJ$@Z$z_oIq2Z|SLrNqML8>IrKnjP2quzv+N$QZ_xx>Sn5s)HDE2Khl z1SCH%9CaF`L~<^qO0o%3m>-V%0i;aw2qbqzSR=2j6iMVYlnO}$?sM{=4M*(-DUr;8 zR7sA86c&V|mP5)U@~TR1VOVn&q)2i*q(bs2B!6T$>Ul_sfr3rB^cc7v2j z+90{3!-yV*-3{oPw5mF`j38ZjLIOmnlAH-C93PIl7*Zy=9+EpDthoHg`46iGHhDkRrI@+XF)?t_#_ehI0PybdXx6ps1? zQYLY4Cp$T;nYb(FLvkpjLUIZue@ZxN9i&8Z8Kg?`eMsTdaMVMPGRd=$+~Tn2KOseu z`rR-elHDPBysVh+)iy|hWIm)wvKUe#SqCYTTned>+yJSPJOIfR!?kaPAlAl3JBvnY6&rU_dxO_TOb9JS0F`_4k`p2Lc>G}hoC(R3TmmVO+yE(({1{Rq*$SzUyathXme%91p7_q?K7tfT2IkR+ zWGtjYau5U`mlyOo0a74Y36Xc`rR%y7QX#npB0q{qYwm;;NS=h0NM3?eNZy6WyYFG(MgE2Iy}ZPJJ2QR&ka_IW}2kZhMeBz-=EJ|yy- zTi(T+-d-~y1(J41iDbF-Avs_AbccPuC4ESKD1Attls+W?CVkEf`@AQ8NcxXLACfVU z3dunbdFOY!U7v$YCRqh(C;2L*o8&u?O(b_iHk14evW?^w$aazsAuVge`3xM5`H+l* zw38eR=_XkO*+jA$vYBKfWE;u#knJS*Lt55_^VtfSO!7LUo#YcpH_6a3m=DP$$Yzqm zA=^k6L$;Hg1!-9y&gbip$s{*J+DRUUbdx*>*+lX-WHU+cv6v6Zo{;S%GaxNzh4X2L zOeXmPq@AP$=_a`bvWes_$Yzo)kZmNdLbj893~4z#oX?PPm=DQBNIS`4kZzL2kWD0K zLpGCaf@~wX6|$Y=F-Xff;e1|%OeT33(oWJm9`hlQ&qpYe%!U-s4LctXsgisVQrZyK zTnNd3DU@p=6_UFk#V?07KZD?dHG-6Q1yUyY08%(VtQjx?^C1}vk>7)=N4uW*#+&FN z`BEs0AQh6;km3bl%|=M>!ceYQIHbJ66r&-LHc|OCOT;(ud?S>GQp?&yCWD-j1a8G>W*ES*f zAB6H2q(V|R1xa#CSThWgyET-FkTS_!Na41y<|Ig!Kn zIjngaBEQ|4Zr2|nWs;8|g*(HVK~pgwlJStz=CGy!$=?;qB1na#3sSs0thor1yC;MswCG!N zlpYCdx*_>WC>KL2B=S?o;-g{B0}%WZ1HpW@LCPd=Kngz%Yw&?}xhlzUi2TNMx?PhY z`6og-Txv*8kv=4AAcZHxQ5QqXB-cUkVR6B_egr9!Y=Klrs*wCs;i&f^C6fL#F&~oA zkiyTxQ3pcGB*#H=Tf&+%AVrc3AQh5pAo-t%qwa*1NS=gLNnU~!ei4p(7g8o^nuYm1 z9oCG56iH@5DkSZY{4c{%%ONF_^C4A|t00A~;ix+xWs;vlt;i3Q3>+ zF`r+BqxOQ7NTx%oBu7FDzYa$&g_KFogXEqGYp#M6N&Xp9A$bCle>NQT5~M`(-;gRv z^8uL8Z^BWdA!U-;5d7ne!Tvb`QY2XgsgPU*$v+>C`W~c2axbJx@-(FILOAMG8Ab9T zq(U;_K+N#B;i%D&0?7f863H=;3dwTm^SiLmdD4gEO6fy#yYwM>O!~YS_W7;!A=xf{ zNE&9N56Pa8-0#Ca(;x+sg%J6?hxF*}ls+UIq|ZxX&E=2+$t{o)$s>>o$#W3-jFEI* ze}WW9>JLI6lHDK`k~T>0<*?5YkOD~&QX)AUQX%=e^r?n@ZjwGE4@n=AXQU6wo6_f% zuuqSJ(T8MLNQtBkQX%;)1RwU9OZU&|(uZV&^db4C^dY%T`n($Uc})6{{7(9i{6+eZ zG#1e3k71vYkOIm6kP^wUkP68eklbrwpAsZb@-0Y#Y=sm_UWb%O{st+N z>@pYgA=w8~C7A=s{YN;T6Crt$Zb*S-Bcw=jJ)}f(Kcq~u6;dJjcSx1w?-2PloAmY? zb|~gUvLB>CG7nND>420-&W4mpz5%I_`~XrVc?6PsE1b{skUYsdkOE1=VVDoeo{%!h zG)R?XAte8w;kr7d56K4ULvp$FA-P5R{3-17i1Z=bf<6KS&>vtECUgozjQoU!~9Xu+PiVhva?fLo#3<`jCu;3`8>P=*!amnaACmi}56M>PL-Oy^=fA=}f0sTa!{(z8$$pS3$vjB@-LOv) zQY1N7`jC86`jFf%ef~S_^SJaOc}e<^yeEA~1{{Gt?}dHFL5d`YK*}U1L8>HcrO*3e zpUb2V$xYISGsz6dCX(YI6_Rz3H%Kmr$S3yI} znFPuA2x}HVN+c^Gm7ZbEB{B-1A(wW(71B-e1f)#z8l>7Q994G|=G;4!y&)Bn*^ny9 zsgUg?=R$G~VV`TI56Qh!gHNAI=lmN;ndHxqD#^g3@pDFe4q`fLBBV%iBxEzm3P_dY z5=cv9*ykolp5zHgk>nLfiKMO_+eNYmq)IXylE>$_rE@+JQXts?*+gpfJ7s=U>63OL|GRf_b96mQOozD}H0?EseZjuin@@b3dsKLkK zf;BzHl!ll&YapX!*-=XDW$)#dW|6eGPH{yAyg z(sR~%ki|Xg zHfhP4rJd`}S}KEk;k#$u?zYc4X`kM%rp4BDr!@_(rl0(2>OS!Mr;n={XqF4~JRX7M zm-N6pfmU>_TUIN?Ud4M&)+O7H^99m^5xTXbHf-3CTe*H+$J%wLtyy=-k|k^AcFkL} zdVTj=`TV8KC2ej=*ZNg+x{l}yM|2$9I;FO3?*D38+fK&KoK@?2*plT-*S0TRGpEaa zK2)%_9hap2c3hHn+hO)?nEkZcns%7|r!C8xJ;r6sggVk3Wl7R+$0cbunf;vL)(S`2 zWjhr0NSplfR~(~PA%AM0mp#x7jBh7OACf~@{Yhpbhgf4WOd zf4@|3x{ReeU-eF!>)g_vZu%z$SVj0rXSoea*Q`!H_bkUBW|r$*v8MC5FRWO$&h5IB z+B)VQHE+s}Iwh*pqBTH`C68tpMXs;!gb9PiOOGg{pi-$`xpRZfYo zGTyp1qjkJTTfE7X_(Z10H*#8hmDA&^Y>oGBi}#)yZ-P&`iydV%;xm~U-^$j>@pZPg z#aB8d-hFDk`^Uig$0#xbfODZl<=3T|6b@ z*l5i-@LFfZ_wkgBn?yeDFm@nJnHk?)*L`X)^M^MU!{hVsdfjaQ9bqz>y2wU-bBO6RO|U;SPwwMdVCw!a5Ah% zy|7sCrrw8>^^85H z;bh7+oDBPLGVa64dd4pH;biK4I9bcYvW zhLdF%PL|^=$n z4JX4IPKGs{3~M+U)>F-}hLd3pC&PN?81~_0J!5BSIGJ({C&L;}hJ83$&)B&>oJ_qB zC+it|OvA~PYd9J9;bh#0ll6>U?8C{_`*5sF{zQNNhm-Y;ou%Pq$~Bw}Yd9J9 z;bc8y=lXCm^*)@eXY4TzCsVHBWY~w3aUV|BGj_2LCsXgk$-0JxClESElljV314JT8r;bb|!N)0Dd?Q+Ga zhLd4E-z>+QXgHZ_J%0>qI2qP(GOXcbSi{M%o@$0QoD6F?8P+q$un#Be89PhE$&_n2 z8P;$z?8C`=#?JNOWa@o5SbN~vaD-nS=Z3AuBl~RPeSXOTh=wWtm|oI-A7ks zLDrtr@UjCmy{v0|S@-!BS&+4_eS+B$KEfgkvUZ<_m>r-gX5Gh_UEp&pvLI`Z`y{g? ze3V5NXqMRpKFsU_pJsM}k2AYK^UTDYMvGxh7Q>onhBeO&`#iIru~L19RI91iATq4E zV%X=I^^7(?&rH3~GwT`a^?7FMHHQrQJTvakO6wVYe4d$le~uaVd1l<_nQ@o*DONm+@Mj*#%j9&gYpK;PcG5&okq-JhKb3_H`}K%!pc^*#%j<&*zyL z;PcFQEzit?TAtYjS$n*eXJ$k#&+G!9XJ$by&&+~ao|y%;JmUpz9kI81LS3@(8$hA% z%s1*X&Zs-Pjk@47>P|_cE)9)pELo1chZHl`bg z_a~O)Gl{*q6f=pv5f7|MYI^H=Y&pI;dLo%>Jyk8oZ%PeIQ>|HMSR>SOe4l9WnQBcR z%kc^7>2IoiNLtT2t}yW8N1P^j;)WqkyH*v4GL55^U=EA>sZgYwSBDEdd)iH zKA)^-90)$0Ouaif_&ru~T+7=VchLf$1Z;c+drdl7mS&r{&4JTV2U!{hVsn&3^9KXf%a5dF>R#}eEM2|^R zt>I)?!^v`dpJ+IlY7HmL@d;`;nQ9+S)-{~0XWYs@oNRr@ZuH?~>ouILYd9JA;bdLI z$$G}E?Ze5|Yd9JA;bcAIK=9#Y>fPDP@3E?dlTmkc7U>x9WX{+I2qM& zvh2dia(weNoNRS`1ND)Ut&VS^K5{bEde~ZyPf!mYTOD7eK5{bE8cvqutJJ5CrdkhI z%kf>M&!SAV9+Q^io1@`ms`W{aVGSq48cvoojh*9j9b}fMpb@3E?dlTmj-8g=1h)ZN-f zT{sza2aHh{PDVAHEW2>B9N#<*CtDrgKn*8b9p6L^CsVD5t>yRx_29A9@l|R#nQ9Fu z%kfoeIGJiaTrJ0Um4=h4)??Cgd~@{7G}RhThBcfFYdBfXIM(7b@!@2;_;9kGaVz_9 zvh^BH)-!g24<}o%;bh#0ll83QE92Jo;bi-0I2rfhWIf|R@Zn_Y-I2;~W2l9bQFlNZ zb>U>x-P%T7I2m;Zj8PX(Mm3x)yKu4`-#iT`TOHp(4JTV2-$V^3Q>}-s<@f~k;IY;5 zRcbhyY7HmL@l|R#nQA>;Eys72hLfq*W72YbbM(wK)f!HQHJl7x*|;biLFk-Edr z{c7oC*&ULWT|QZMx431OP?p_cW7%btWeur_yOfG}#)fK6Md~v)Rg)@GpRuu;RkmIa zQxB&|ea3nU*b>wi$l?`XjRqKC2Vqo-TMGj3izTy1^yjSN_?p0>8$ z|D?;zQ?tv~Yj{OGW1i7>0AM~ozigx0&;87d{AV>pMr7S){(}}GBeM2J?MH}qk#l!7HOqfW*7J{i!8`GJbavCMDUR??Q2$d&RM^#_IWt^F$-DC+x!p3 zvX;+u!87Gk`cKWB-qpT(?VPU2x~G21*l9Z%JMB}(PT$Gc>7O!o#!kl0$Q-NtD?YZi zENfrZ9t>vhtC^p&-kH%k>w2@t>Uw8I$JUl*%~^ZL$JUl*jZN-UvNw1qN3M29L2Pug z@Ke?upSYjctWVk7cr(pT)}1|C&zX$T$-?N&-G@Nw8EaM@EZh0m$k~{T%{Uv~XG`f% z*rMz8Kb^{2uihN-_12bUjjg?099^$}u{?9En^z=3lI_VzkYs;E5+qo*^Yvzob#ux{ zAN1D!5g%JymbqU46gYcdWu!o|KOzYdEX!K2&MQ8)wk&IG@=!5*(pf2x%q*4y;liwS z>)bL%Ckt1uT+@bcf8Qk^gjl=p%<-Z*awnIuEFC5v^F|$mVP;u6Og?umYnWN)hsi#` zrxr$s#g+xbvL@+v>kci`VP^idZNo4u>z2m=@~M#F;{f+DPgzT*W{#Pbxnz3gk{Ovx zW@av#mAM4RP1dv#?vX|A$wPE6xFykTbxWe#>Xt;e)h&r`kz0a!cdc1?X#3obPIp7d Y5gUHyXJ_~Nj%90>p4l;P{)XKD0ND<_@Bjb+ literal 0 HcmV?d00001 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/gmon.out b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/gmon.out new file mode 100644 index 0000000000000000000000000000000000000000..25926256751f0c772765e4dc652bcc22f782af5c GIT binary patch literal 4562 zcmYe#&Cg?GKm!Zd9l#@~W4hDu4ph$6Qa(-S)F<1`7g)v6y(GVC7fzc2c4S~@R w7!85Z5Eu=C(GVC7fzc2c4S~@R7!85Z5Eu;s+Jpe(0Zj+6$=^62G-xCT0HH7nlK=n! literal 0 HcmV?d00001 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c new file mode 100644 index 0000000000..d5ae637b08 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.c @@ -0,0 +1,100831 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z384_13(int8_t* cnProcBuf,int8_t* cnProcBufRes) { + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + ymm0 = ((__m256i*)&cnProcBuf)[12]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[24]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[13]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[25]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[14]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[26]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[15]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[27]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[4] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[16]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[28]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[5] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[17]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[29]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[6] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[18]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[30]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[7] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[19]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[31]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[20]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[32]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[21]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[33]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[22]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[34]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[23]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[35]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[0]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[24]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[25]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[2]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[26]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[3]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[27]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[4]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[28]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[5]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[29]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[6]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[30]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[7]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[31]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[32]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[33]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[10]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[34]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[11]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[35]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[0]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[12]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[13]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[2]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[14]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[3]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[15]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[4]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[16]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[5]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[17]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[6]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[18]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[7]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[19]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[20]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[21]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[10]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[22]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[11]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[23]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1212]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[5] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1213]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[6] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1214]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[7] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1215]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1216]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1217]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1218]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1219]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1220]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1221]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1222]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1223]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1224]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1225]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1226]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1227]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1228]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1229]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1230]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1231]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1232]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1233]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1234]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1235]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1236]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1237]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1238]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1239]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1240]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1241]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1242]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1243]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1244]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1245]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1246]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1247]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1248]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1249]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1250]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1251]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1252]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1253]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1254]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1255]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1256]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1257]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1258]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1259]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1260]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1261]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1262]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1263]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1152]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1153]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1154]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1155]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1156]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1157]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1158]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1159]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1208]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[121] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1209]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[122] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1210]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[123] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1211]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[124] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1152]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[125] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1153]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[126] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1154]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[127] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1155]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[128] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1156]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[129] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1157]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[130] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1158]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[131] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1159]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[132] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[133] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[134] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[135] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[136] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[137] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[138] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[139] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[140] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[141] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[142] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[143] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[146] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[147] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[148] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[149] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[150] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[151] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[152] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[153] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[154] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[155] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[157] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[158] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[159] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[160] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[161] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[162] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[163] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[164] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[165] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[166] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[167] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[168] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[169] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[170] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[171] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[172] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[173] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[174] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[175] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[176] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[177] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[178] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[179] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[180] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1208]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[181] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1209]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[182] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1210]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[183] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1211]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[184] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1152]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[185] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1153]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[186] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1154]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[187] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1155]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[188] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1156]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[189] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1157]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[190] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1158]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[191] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1159]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[192] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[193] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[194] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[195] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[196] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[197] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[198] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[199] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[200] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[201] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[202] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[203] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[204] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[205] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[206] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[207] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[208] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[209] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[210] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[211] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[212] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[213] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[214] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[215] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[217] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[218] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[219] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[220] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[221] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[222] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[223] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[224] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[225] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[226] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[227] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[228] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[229] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[230] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[231] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[232] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[233] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[234] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[235] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[236] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[237] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[238] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[239] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[240] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1208]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[241] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1209]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[242] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1210]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[243] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[1211]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[1331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[244] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9048]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9049]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9050]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9051]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9052]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9053]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9054]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9055]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9056]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9057]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9058]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9059]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9060]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9061]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9062]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9063]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9064]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9065]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9066]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9067]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9068]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9069]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9070]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9071]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9072]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9073]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9074]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9075]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9076]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9077]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9078]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9079]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9080]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9081]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9082]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9083]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9084]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9085]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9086]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9087]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9088]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9089]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9090]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9091]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9092]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9093]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9094]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9095]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9096]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9097]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9098]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9099]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9100]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9101]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9102]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9103]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9104]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9105]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9106]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9107]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9108]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9109]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9110]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9111]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9112]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9113]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9114]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9115]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9116]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9117]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9118]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9119]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9120]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9121]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9122]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9123]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9124]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9125]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9126]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9127]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9128]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9129]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9130]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9131]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9132]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9133]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9134]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9135]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9136]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9137]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9138]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9139]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9140]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9141]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9142]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9143]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9144]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9145]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9146]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9147]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9148]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9149]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9150]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9151]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[121] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9152]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[122] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9153]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[123] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9154]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[124] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9155]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[125] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9156]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[126] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9157]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[127] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9158]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[128] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9159]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[129] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[130] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[131] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[132] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[133] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[134] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[135] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[136] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[137] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[138] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[139] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[140] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[141] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[142] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[143] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[146] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[147] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[148] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[149] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[150] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[151] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[152] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[153] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[154] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[155] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[157] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[158] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[159] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[160] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[161] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[162] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[163] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[164] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[165] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[166] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[167] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[168] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[169] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[170] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[171] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[172] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[173] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[174] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[175] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[176] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[177] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9208]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[178] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9209]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[179] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9210]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[180] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9211]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[181] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9212]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[182] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9213]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[183] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9214]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[184] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9215]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[185] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9216]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[186] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9217]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[187] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9218]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[188] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9219]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[189] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9220]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[190] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9221]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[191] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9222]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[192] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9223]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[193] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9224]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[194] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9225]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[195] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9226]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[196] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9227]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[197] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9228]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[198] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9229]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[199] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9230]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[200] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9231]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[201] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9232]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[202] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9233]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[203] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9234]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[204] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9235]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[205] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9236]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[206] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9237]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[207] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9238]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[208] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9239]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[209] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9240]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[210] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9241]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[211] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9242]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[212] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9243]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[213] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9244]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[214] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9245]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[215] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9246]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9247]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[217] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9248]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[218] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9249]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[219] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9250]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[220] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9251]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[221] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9252]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[222] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9253]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[223] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9254]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[224] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9255]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[225] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9256]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[226] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9257]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[227] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9258]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[228] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9259]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[229] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9260]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[230] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9261]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[231] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9262]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[232] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9263]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[233] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[234] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[235] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[236] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[237] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[238] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[239] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[240] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[241] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[242] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[243] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[244] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[245] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[246] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[247] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[248] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[249] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[250] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[251] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[252] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[253] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[254] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[255] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[256] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[257] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[258] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[259] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[260] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[261] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[262] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[263] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[264] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[265] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[266] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[267] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[268] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[269] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[270] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[271] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[272] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[273] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[274] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[275] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[277] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[278] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[279] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[280] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[281] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[282] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[283] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[284] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[285] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8884]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[286] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8885]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[287] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8886]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[288] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8887]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[289] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8888]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[290] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8889]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[291] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8890]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[292] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8891]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[293] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8892]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[294] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8893]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[295] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8894]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[296] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8895]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[297] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8896]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[298] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8897]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[299] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8898]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[300] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8899]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[301] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8900]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[302] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8901]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[303] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8902]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[304] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8903]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[305] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8904]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[306] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8905]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[307] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8906]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[308] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8907]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[309] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8908]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[310] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8909]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[311] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8910]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[312] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8911]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[313] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8912]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[314] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8913]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[315] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8914]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[316] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8915]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[317] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8916]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[318] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8917]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[319] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8918]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[320] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8919]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[321] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8920]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[322] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8921]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[323] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8922]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[324] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8923]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[325] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8924]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[326] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8925]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[327] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8926]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[328] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8927]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[329] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8928]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[330] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8929]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[331] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8930]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[332] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8931]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[333] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8932]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[334] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8933]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[335] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8934]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[336] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8935]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[337] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8936]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[338] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8937]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[339] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8938]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[340] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8939]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[341] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8940]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[342] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8941]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[343] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8942]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[344] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8943]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[345] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8944]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[346] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8945]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[347] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8946]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[348] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8947]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[349] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8948]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[350] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8949]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[351] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8950]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[352] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8951]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[353] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8952]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[354] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8953]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[355] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8954]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[356] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8955]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[357] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8956]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[358] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8957]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[359] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8958]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[360] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8959]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[361] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8960]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[362] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8961]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[363] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8962]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[364] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8963]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[365] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8964]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[366] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8965]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[367] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8966]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[368] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8967]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[369] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8968]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[370] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8969]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[371] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8970]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[372] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8971]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[373] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8972]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[374] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8973]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[375] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8974]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[376] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8975]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[377] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8976]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[378] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8977]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[379] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8978]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[380] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8979]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[381] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8980]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[382] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8981]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[383] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8982]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[384] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8983]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[385] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8984]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[386] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8985]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[387] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8986]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[388] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8987]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[389] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8988]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[390] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8989]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[391] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8990]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[392] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8991]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[393] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8992]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[394] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8993]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[395] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8994]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[396] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8995]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[397] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8996]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[398] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8997]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[399] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8998]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[400] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8999]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[401] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9000]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[402] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9001]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[403] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9002]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[404] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9003]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[405] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9004]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[406] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9005]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[407] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9006]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[408] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9007]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[409] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9008]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[410] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9009]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[411] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9010]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[412] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9011]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[413] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9012]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[414] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9013]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[415] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9014]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[416] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9015]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[417] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9016]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[418] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9017]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[419] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9018]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[420] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9019]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[421] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9020]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[422] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9021]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[423] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9022]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[424] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9023]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[425] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9024]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[426] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9025]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[427] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9026]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[428] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9027]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[429] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9028]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[430] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9029]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[431] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9030]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[432] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9031]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[433] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9032]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[434] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9033]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[435] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9034]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[436] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9035]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[437] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9036]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[438] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9037]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[439] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9038]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[440] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9039]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[441] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9040]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[442] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9041]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[443] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9042]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[444] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9043]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[445] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9044]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[446] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9045]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[447] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9046]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[448] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9047]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[449] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[450] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[451] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[452] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[453] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[454] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[455] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[457] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[458] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[459] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[460] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[461] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[462] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[463] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[464] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[465] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[466] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[467] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[468] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[469] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[470] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[471] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[472] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[473] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[474] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[475] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[476] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[477] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[478] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[479] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[480] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[481] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[482] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[483] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[484] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[485] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[486] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[487] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[488] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[489] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[490] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[491] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[493] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[494] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[495] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[496] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[497] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[498] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[499] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[500] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[501] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8884]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[502] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8885]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[503] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8886]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[504] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8887]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[505] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8888]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[506] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8889]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[507] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8890]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[508] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8891]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[509] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8892]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[510] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8893]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[511] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8894]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[512] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8895]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[513] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8896]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[514] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8897]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[515] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8898]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[516] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8899]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[517] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8900]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[518] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8901]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[519] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8902]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[520] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8903]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[521] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8904]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[522] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8905]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[523] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8906]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[524] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8907]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[525] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8908]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[526] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8909]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[527] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8910]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[528] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8911]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[529] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8912]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[530] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8913]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[531] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8914]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[532] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8915]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[533] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8916]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[534] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8917]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[535] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8918]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[536] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8919]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[537] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8920]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[538] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8921]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[539] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8922]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[540] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8923]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[541] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8924]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[542] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8925]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[543] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8926]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[544] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8927]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[545] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8928]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[546] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8929]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[547] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8930]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[548] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8931]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[549] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8932]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[550] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8933]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[551] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8934]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[552] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8935]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[553] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8936]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[554] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8937]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[555] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8938]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[556] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8939]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[557] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8940]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[558] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8941]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[559] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8942]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[560] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8943]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[561] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8944]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[562] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8945]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[563] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8946]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[564] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8947]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[565] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8948]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[566] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8949]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[567] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8950]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[568] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8951]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[569] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8952]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[570] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8953]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[571] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8954]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[572] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8955]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[573] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8956]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[574] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8957]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[575] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8958]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[576] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8959]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[577] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8960]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[578] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8961]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[579] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8962]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[580] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8963]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[581] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8964]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[582] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8965]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[583] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8966]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[584] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8967]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[585] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8968]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[586] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8969]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[587] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8970]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[588] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8971]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[589] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8972]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[590] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8973]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[591] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8974]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[592] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8975]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[593] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8976]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[594] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8977]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[595] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8978]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[596] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8979]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[597] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8980]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[598] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8981]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[599] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8982]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[600] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8983]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[601] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8984]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[602] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8985]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[603] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8986]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[604] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8987]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[605] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8988]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[606] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8989]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[607] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8990]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[608] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8991]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[609] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8992]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[610] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8993]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[611] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8994]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[612] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8995]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[613] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8996]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[614] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8997]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[615] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8998]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[616] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8999]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[617] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9000]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[618] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9001]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[619] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9002]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[620] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9003]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[621] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9004]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[622] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9005]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[623] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9006]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[624] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9007]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[625] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9008]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[626] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9009]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[627] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9010]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[628] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9011]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[629] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9012]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[630] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9013]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[631] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9014]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[632] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9015]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[633] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9016]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[634] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9017]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[635] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9018]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[636] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9019]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[637] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9020]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[638] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9021]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[639] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9022]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[640] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9023]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[641] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9024]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[642] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9025]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[643] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9026]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[644] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9027]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[645] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9028]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[646] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9029]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[647] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9030]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[648] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9031]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[649] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9032]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[650] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9033]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[651] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9034]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[652] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9035]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[653] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9036]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[654] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9037]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[655] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9038]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[656] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9039]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[657] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9040]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[658] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9041]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[659] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9042]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[660] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9043]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[661] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9044]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[662] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9045]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[663] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9046]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[664] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9047]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[665] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[666] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[667] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[668] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[669] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[670] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[671] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[672] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[673] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[674] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[675] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[676] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[677] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[678] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[679] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[680] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[681] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[682] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[683] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[684] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[685] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[686] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[687] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[688] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[689] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[690] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[691] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[692] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[693] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[694] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[695] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[697] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[698] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[699] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[700] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[701] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[702] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[703] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[704] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[705] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[706] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[707] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[709] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[710] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[711] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[712] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[713] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[714] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[715] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[716] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[717] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8884]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[718] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8885]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[719] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8886]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[720] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8887]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[721] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8888]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[722] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8889]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[723] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8890]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[724] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8891]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[725] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8892]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[726] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8893]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[727] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8894]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[728] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8895]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[729] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8896]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[730] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8897]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[731] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8898]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[732] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8899]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[733] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8900]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[734] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8901]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[735] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8902]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[736] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8903]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[737] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8904]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[738] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8905]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[739] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8906]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[740] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8907]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[741] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8908]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[742] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8909]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[743] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8910]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[744] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8911]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[745] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8912]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[746] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8913]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[747] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8914]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[748] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8915]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[749] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8916]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[750] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8917]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[751] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8918]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[752] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8919]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[753] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8920]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[754] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8921]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[755] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8922]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[756] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8923]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[757] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8924]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[758] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8925]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[759] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8926]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[760] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8927]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[761] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8928]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[762] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8929]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[763] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8930]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[764] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8931]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[765] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8932]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[766] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8933]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[767] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8934]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[768] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8935]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[769] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8936]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[770] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8937]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[771] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8938]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[772] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8939]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[773] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8940]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[774] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8941]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[775] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8942]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[776] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8943]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[777] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8944]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[778] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8945]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[779] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8946]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[780] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8947]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[781] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8948]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[782] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8949]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[783] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8950]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[784] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8951]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[785] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8952]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[786] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8953]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[787] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8954]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[788] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8955]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[789] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8956]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[790] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8957]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[791] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8958]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[792] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8959]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[793] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8960]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[794] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8961]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[795] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8962]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[796] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8963]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[797] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8964]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[798] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8965]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[799] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8966]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[800] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8967]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[801] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8968]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[802] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8969]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[803] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8970]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[804] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8971]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[805] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8972]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[806] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8973]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[807] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8974]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[808] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8975]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[809] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8976]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[810] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8977]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[811] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8978]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[812] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8979]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[813] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8980]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[814] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8981]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[815] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8982]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[816] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8983]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[817] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8984]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[818] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8985]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[819] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8986]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[820] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8987]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[821] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8988]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[822] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8989]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[823] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8990]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[824] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8991]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[825] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8992]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[826] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8993]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[827] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8994]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[828] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8995]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[829] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8996]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[830] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8997]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[831] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8998]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[832] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8999]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[833] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9000]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[834] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9001]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[835] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9002]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[836] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9003]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[837] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9004]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[838] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9005]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[839] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9006]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[840] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9007]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[841] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9008]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[842] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9009]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[843] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9010]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[844] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9011]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[845] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9012]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[846] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9013]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[847] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9014]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[848] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9015]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[849] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9016]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[850] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9017]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[851] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9018]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[852] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9019]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[853] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9020]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[854] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9021]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[855] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9022]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[856] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9023]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[857] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9024]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[858] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9025]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[859] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9026]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[860] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9027]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[861] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9028]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[862] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9029]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[863] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9030]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[864] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9031]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[865] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9032]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[866] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9033]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[867] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9034]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[868] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9035]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[869] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9036]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[870] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9037]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[871] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9038]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[872] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9039]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[873] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9040]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[874] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9041]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[875] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9042]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[876] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9043]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[877] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9044]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[878] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9045]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[879] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9046]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[880] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9047]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[881] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[882] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[883] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[884] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[885] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[886] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[887] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[888] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[889] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[890] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[891] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[892] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[893] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[894] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[895] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[896] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[897] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[898] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[899] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[900] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[901] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[902] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[903] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[904] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[905] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[906] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[907] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[908] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[909] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[910] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[911] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[912] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[913] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[914] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[915] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[916] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[917] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[918] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[919] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[920] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[921] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[922] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[923] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[925] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[926] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[927] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[928] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[929] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[930] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[931] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[932] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[933] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8884]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[934] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8885]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[935] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8886]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8887]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[937] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8888]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[938] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8889]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[939] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8890]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[940] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8891]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[941] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8892]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[942] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8893]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[943] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8894]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[944] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8895]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[945] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8896]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[946] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8897]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[947] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8898]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[948] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8899]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[949] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8900]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[950] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8901]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[951] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8902]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[952] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8903]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[953] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8904]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[954] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8905]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[955] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8906]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[956] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8907]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[957] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8908]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[958] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8909]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[959] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8910]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[960] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8911]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[961] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8912]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[962] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8913]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[963] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8914]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[964] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8915]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[965] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8916]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[966] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8917]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[967] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8918]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[968] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8919]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[969] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8920]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[970] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8921]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[971] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8922]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[972] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8923]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[973] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8924]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[974] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8925]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[975] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8926]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[976] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8927]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[977] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8928]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[978] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8929]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[979] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8930]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[980] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8931]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[981] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8932]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[982] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8933]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[983] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8934]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[984] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8935]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[985] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8936]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[986] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8937]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[987] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8938]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[988] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8939]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[989] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8940]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[990] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8941]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[991] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8942]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[992] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8943]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[993] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8944]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[994] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8945]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[995] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8946]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[996] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8947]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[997] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8948]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[998] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8949]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[999] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8950]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1000] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8951]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1001] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8952]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1002] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8953]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1003] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8954]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1004] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8955]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1005] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8956]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1006] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8957]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1007] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8958]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1008] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8959]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1009] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8960]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1010] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8961]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1011] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8962]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1012] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8963]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1013] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8964]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1014] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8965]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1015] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8966]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1016] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8967]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1017] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8968]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1018] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8969]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1019] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8970]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1020] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8971]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1021] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8972]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1022] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8973]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1023] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8974]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1024] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8975]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1025] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8976]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1026] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8977]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1027] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8978]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1028] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8979]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1029] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8980]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1030] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8981]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1031] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8982]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1032] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8983]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1033] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8984]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1034] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8985]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1035] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8986]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1036] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8987]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1037] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8988]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1038] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8989]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1039] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8990]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1040] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8991]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1041] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8992]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1042] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8993]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1043] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8994]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1044] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8995]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1045] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8996]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1046] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8997]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1047] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8998]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1048] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[8999]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1049] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9000]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1050] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9001]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1051] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9002]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1052] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9003]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1053] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9004]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1054] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9005]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1055] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9006]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1056] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9007]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1057] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9008]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1058] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9009]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1059] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9010]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1060] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9011]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1061] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9012]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1062] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9013]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1063] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9014]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1064] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9015]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1065] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9016]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1066] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9017]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1067] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9018]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1068] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9019]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1069] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9020]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1070] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9021]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1071] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9022]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1072] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9023]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1073] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9024]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1074] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9025]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1075] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9026]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1076] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9027]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1077] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9028]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1078] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9029]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1079] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9030]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1080] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9031]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1081] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9032]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1082] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9033]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1083] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9034]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1084] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9035]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1085] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9036]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1086] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9037]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1087] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9038]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1088] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9039]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1089] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9040]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1090] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9041]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1091] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9042]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1092] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9043]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1093] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9044]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1094] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9045]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1095] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9046]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1096] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[9047]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[9695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1097] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43488]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43489]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43490]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43491]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43492]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43493]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43494]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43495]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43496]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43497]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43498]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43499]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43500]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43501]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43502]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43503]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43504]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43505]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43506]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43507]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43508]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43509]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43510]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43511]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43512]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43513]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43514]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43515]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43516]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43517]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43518]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43519]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43520]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43521]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43522]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43523]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43524]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43525]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43526]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43527]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43528]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43529]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43530]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43531]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43532]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43533]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43534]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43535]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43536]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43537]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43538]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43539]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43540]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43541]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43542]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43543]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43544]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43545]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43546]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43547]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43548]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43549]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43550]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43551]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43552]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43553]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43554]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43555]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43556]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43557]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43558]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43559]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43560]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43561]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43562]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43563]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43564]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43565]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43566]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43567]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43568]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43569]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43570]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43571]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43572]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43573]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43574]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43575]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43576]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43577]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43578]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43579]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43580]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43581]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43582]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43583]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43392]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43393]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43394]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43395]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43396]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43397]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43398]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43399]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43400]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43401]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43402]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43403]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43404]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43405]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43406]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43407]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[121] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[122] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[123] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[124] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[125] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[126] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[127] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[128] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[129] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[130] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[131] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[132] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[133] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[134] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[135] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[136] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[137] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[138] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[139] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[140] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[141] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[142] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[143] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43432]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43433]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43434]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[146] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43435]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[147] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43436]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[148] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43437]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[149] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43438]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[150] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43439]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[151] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43440]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[152] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43441]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[153] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43442]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[154] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43443]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[155] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43444]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43445]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[157] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43446]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[158] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43447]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[159] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43448]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[160] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43449]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[161] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43450]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[162] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43451]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[163] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43452]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[164] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43453]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[165] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43454]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[166] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43455]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[167] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43456]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[168] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43457]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[169] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43458]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[170] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43459]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[171] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43460]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[172] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43461]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[173] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43462]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[174] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43463]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[175] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43464]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[176] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43465]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[177] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43466]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[178] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43467]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[179] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43468]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[180] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43469]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[181] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43470]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[182] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43471]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[183] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43472]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[184] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43473]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[185] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43474]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[186] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43475]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[187] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43476]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[188] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43477]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[189] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43478]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[190] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43479]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[191] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43480]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[192] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43481]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[193] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43482]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[194] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43483]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[195] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43484]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[196] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43485]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[197] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43486]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[198] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43487]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[199] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43392]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[200] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43393]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[201] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43394]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[202] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43395]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[203] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43396]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[204] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43397]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[205] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43398]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[206] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43399]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[207] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43400]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[208] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43401]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[209] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43402]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[210] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43403]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[211] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43404]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[212] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43405]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[213] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43406]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[214] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43407]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[215] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[217] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[218] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[219] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[220] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[221] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[222] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[223] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[224] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[225] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[226] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[227] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[228] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[229] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[230] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[231] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[232] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[233] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[234] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[235] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[236] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[237] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[238] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[239] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43432]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[240] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43433]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[241] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43434]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[242] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43435]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[243] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43436]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[244] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43437]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[245] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43438]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[246] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43439]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[247] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43440]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[248] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43441]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[249] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43442]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[250] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43443]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[251] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43444]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[252] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43445]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[253] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43446]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[254] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43447]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[255] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43448]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[256] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43449]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[257] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43450]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[258] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43451]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[259] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43452]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[260] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43453]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[261] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43454]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[262] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43455]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[263] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43456]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[264] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43457]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[265] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43458]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[266] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43459]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[267] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43460]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[268] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43461]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[269] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43462]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[270] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43463]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[271] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43464]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[272] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43465]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[273] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43466]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[274] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43467]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[275] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43468]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43469]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[277] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43470]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[278] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43471]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[279] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43472]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[280] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43473]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[281] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43474]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[282] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43475]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[283] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43476]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[284] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43477]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[285] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43478]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[286] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43479]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[287] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43480]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[288] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43481]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[289] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43482]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[290] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43483]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[291] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43484]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[292] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43485]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[293] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43486]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[294] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43487]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[295] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43392]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[296] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43393]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[297] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43394]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[298] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43395]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[299] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43396]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[300] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43397]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[301] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43398]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[302] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43399]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[303] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43400]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[304] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43401]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[305] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43402]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[306] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43403]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[307] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43404]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[308] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43405]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[309] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43406]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[310] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43407]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[311] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[312] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[313] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[314] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[315] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[316] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[317] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[318] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[319] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[320] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[321] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[322] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[323] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[324] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[325] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[326] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[327] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[328] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[329] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[330] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[331] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[332] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[333] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[334] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[335] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43432]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[336] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43433]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[337] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43434]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[338] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43435]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[339] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43436]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[340] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43437]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[341] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43438]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[342] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43439]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[343] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43440]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[344] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43441]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[345] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43442]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[346] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43443]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[347] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43444]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[348] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43445]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[349] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43446]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[350] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43447]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[351] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43448]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[352] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43449]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[353] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43450]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[354] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43451]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[355] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43452]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[356] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43453]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[357] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43454]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[358] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43455]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[359] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43456]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[360] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43457]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[361] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43458]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[362] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43459]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[363] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43460]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[364] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43461]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[365] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43462]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[366] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43463]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[367] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43464]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[368] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43465]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[369] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43466]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[370] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43467]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[371] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43468]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[372] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43469]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[373] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43470]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[374] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43471]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[375] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43472]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[376] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43473]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[377] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43474]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[378] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43475]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[379] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43476]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[380] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43477]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[381] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43478]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[382] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43479]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[383] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43480]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[384] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43481]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[385] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43482]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[386] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43483]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[387] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43484]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[388] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43485]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[389] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43486]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[390] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43487]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[391] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43392]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[392] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43393]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[393] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43394]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[394] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43395]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[395] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43396]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[396] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43397]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[397] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43398]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[398] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43399]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[399] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43400]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[400] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43401]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[401] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43402]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[402] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43403]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[403] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43404]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[404] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43405]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[405] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43406]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[406] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43407]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[407] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[408] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[409] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[410] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[411] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[412] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[413] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[414] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[415] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[416] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[417] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[418] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[419] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[420] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[421] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[422] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[423] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[424] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[425] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[426] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[427] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[428] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[429] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[430] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[431] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43432]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[432] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43433]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[433] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43434]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[434] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43435]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[435] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43436]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[436] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43437]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[437] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43438]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[438] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43439]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[439] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43440]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[440] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43441]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[441] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43442]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[442] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43443]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[443] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43444]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[444] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43445]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[445] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43446]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[446] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43447]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[447] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43448]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[448] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43449]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[449] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43450]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[450] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43451]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[451] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43452]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[452] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43453]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[453] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43454]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[454] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43455]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[455] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43456]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43457]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[457] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43458]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[458] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43459]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[459] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43460]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[460] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43461]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[461] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43462]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[462] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43463]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[463] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43464]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[464] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43465]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[465] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43466]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[466] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43467]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[467] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43468]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[468] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43469]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[469] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43470]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[470] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43471]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[471] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43472]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[472] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43473]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[473] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43474]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[474] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43475]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[475] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43476]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[476] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43477]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[477] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43478]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[478] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43479]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[479] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43480]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[480] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43481]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[481] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43482]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[482] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43483]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[483] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43484]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[484] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43485]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[485] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43486]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[486] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43487]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[487] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43392]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[488] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43393]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[489] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43394]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[490] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43395]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[491] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43396]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43397]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[493] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43398]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[494] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43399]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[495] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43400]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[496] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43401]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[497] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43402]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[498] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43403]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[499] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43404]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[500] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43405]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[501] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43406]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[502] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43407]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[503] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[504] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[505] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[506] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[507] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[508] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[509] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[510] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[511] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[512] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[513] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[514] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[515] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[516] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[517] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[518] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[519] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[520] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[521] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[522] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[523] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[524] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[525] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[526] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[527] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43432]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[528] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43433]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[529] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43434]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[530] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43435]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[531] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43436]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[532] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43437]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[533] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43438]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[534] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43439]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[535] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43440]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[536] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43441]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[537] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43442]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[538] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43443]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[539] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43444]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[540] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43445]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[541] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43446]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[542] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43447]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[543] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43448]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[544] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43449]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[545] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43450]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[546] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43451]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[547] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43452]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[548] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43453]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[549] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43454]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[550] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43455]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[551] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43456]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[552] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43457]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[553] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43458]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[554] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43459]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[555] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43460]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[556] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43461]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[557] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43462]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[558] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43463]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[559] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43464]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[560] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43465]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[561] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43466]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[562] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43467]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[563] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43468]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[564] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43469]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[565] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43470]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[566] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43471]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[567] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43472]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[568] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43473]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[569] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43474]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[570] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43475]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[571] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43476]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[572] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43477]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[573] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43478]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[574] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43479]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[575] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43480]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[576] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43481]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[577] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43482]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[578] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43483]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[579] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43484]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[580] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43485]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[581] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43486]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[582] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[43487]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[43871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[583] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61884]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[5] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61885]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[6] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61886]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[7] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61887]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61888]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61889]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61890]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61891]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61892]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61893]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61894]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61895]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61896]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61897]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61898]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61899]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61900]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61901]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61902]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61903]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61904]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61905]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61906]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61907]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61908]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61909]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61910]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61911]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61912]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61913]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61914]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61915]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61916]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61917]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61918]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61919]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61920]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61921]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61922]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61923]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61924]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61925]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61926]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61927]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61928]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61929]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61930]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61931]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61932]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61933]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61934]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61935]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61936]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61937]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61938]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61939]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61940]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61941]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61942]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61943]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61824]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61825]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61826]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61827]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61828]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61829]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61830]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61831]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[121] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[122] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[123] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[124] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61824]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[125] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61825]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[126] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61826]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[127] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61827]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[128] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61828]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[129] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61829]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[130] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61830]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[131] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61831]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[132] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[133] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[134] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[135] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[136] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[137] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[138] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[139] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[140] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[141] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[142] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[143] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[146] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[147] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[148] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[149] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[150] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[151] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[152] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[153] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[154] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[155] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[157] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[158] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[159] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[160] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[161] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[162] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[163] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[164] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[165] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[166] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[167] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[168] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[169] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[170] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[171] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[172] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[173] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[174] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[175] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[176] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[177] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[178] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[179] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[180] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[181] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[182] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[183] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[184] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61824]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[185] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61825]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[186] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61826]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[187] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61827]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[188] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61828]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[189] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61829]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[190] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61830]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[191] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61831]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[192] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[193] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[194] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[195] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[196] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[197] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[198] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[199] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[200] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[201] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[202] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[203] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[204] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[205] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[206] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[207] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[208] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[209] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[210] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[211] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[212] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[213] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[214] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[215] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[217] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[218] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[219] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[220] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[221] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[222] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[223] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[224] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[225] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[226] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[227] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[228] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[229] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[230] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[231] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[232] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[233] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[234] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[235] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[236] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[237] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[238] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[239] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[240] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[241] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[242] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[243] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[244] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61824]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[245] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61825]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[246] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61826]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[247] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61827]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[248] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61828]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[249] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61829]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[250] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61830]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[251] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61831]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[252] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[253] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[254] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[255] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[256] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[257] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[258] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[259] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[260] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[261] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[262] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[263] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[264] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[265] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[266] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[267] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[268] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[269] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[270] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[271] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[272] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[273] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[274] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[275] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[277] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[278] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[279] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[280] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[281] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[282] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[283] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[284] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[285] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[286] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[287] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[288] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[289] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[290] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[291] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[292] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[293] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[294] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[295] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[296] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[297] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[298] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[299] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[300] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[301] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[302] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[303] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[304] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61824]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62184]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[305] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61825]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62185]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[306] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61826]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62186]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[307] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61827]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62187]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[308] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61828]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62188]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[309] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61829]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62189]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[310] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61830]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62190]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[311] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61831]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62191]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[312] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62192]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[313] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62193]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[314] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62194]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[315] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62195]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[316] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62196]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[317] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62197]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[318] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62198]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[319] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62199]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[320] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62200]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[321] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62201]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[322] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62202]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[323] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62203]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[324] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62204]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[325] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62205]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[326] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62206]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[327] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62207]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[328] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[329] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[330] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[331] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[332] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[333] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[334] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[335] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[336] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[337] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[338] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[339] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[340] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[341] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[342] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[343] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[344] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[345] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[346] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[347] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[348] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[349] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[350] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[351] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[352] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[353] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[354] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[355] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[356] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[357] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[358] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[359] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[360] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[361] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[362] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[363] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[364] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61824]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62124]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[365] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61825]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62125]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[366] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61826]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62126]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[367] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61827]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62127]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[368] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61828]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62128]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[369] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61829]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62129]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[370] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61830]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62130]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[371] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61831]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62131]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[372] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61832]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62072]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62132]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[373] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61833]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62073]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62133]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[374] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61834]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62074]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62134]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[375] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61835]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62075]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62135]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[376] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61836]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62076]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62136]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[377] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61837]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62077]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62137]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[378] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61838]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62078]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62138]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[379] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61839]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62079]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62139]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[380] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61840]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62080]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62140]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[381] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61841]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62081]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62141]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[382] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61842]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62082]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62142]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[383] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61843]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62083]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62143]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[384] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61844]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62084]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62144]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[385] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61845]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62085]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62145]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[386] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61846]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62086]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62146]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[387] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61847]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62087]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62147]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[388] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61848]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62088]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62148]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[389] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61849]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62089]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62149]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[390] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61850]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62090]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62150]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[391] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61851]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62091]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62151]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[392] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61852]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62092]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62152]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[393] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61853]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62093]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62153]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[394] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61854]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62094]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62154]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[395] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61855]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62095]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62155]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[396] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61856]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62096]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62156]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[397] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61857]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62097]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62157]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[398] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61858]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62098]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62158]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[399] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61859]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62099]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62159]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[400] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61860]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62100]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62160]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[401] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61861]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62101]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62161]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[402] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61862]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62102]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62162]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[403] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61863]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62103]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62163]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[404] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61864]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62104]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62164]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[405] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61865]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62105]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62165]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[406] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61866]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62106]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62166]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[407] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61867]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62107]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62167]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[408] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61868]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62108]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62168]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[409] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61869]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62109]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62169]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[410] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61870]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62110]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62170]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[411] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61871]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62111]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62171]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[412] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61872]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62112]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62172]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[413] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61873]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62113]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62173]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[414] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61874]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62114]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62174]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[415] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61875]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62115]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62175]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[416] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61876]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62116]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62176]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[417] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61877]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62117]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62177]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[418] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61878]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62118]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62178]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[419] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61879]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62119]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62179]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[420] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61880]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62120]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62180]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[421] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61881]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62121]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62181]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[422] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61882]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62122]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62182]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[423] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[61883]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[61943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62123]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[62183]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[424] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75288]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75289]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75290]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[4] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75291]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[5] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75292]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[6] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75293]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[7] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75294]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75295]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75296]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75297]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75298]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75299]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75300]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75301]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75302]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75303]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75304]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75305]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75306]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75307]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75308]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75309]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75310]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75311]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75272]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75273]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75274]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75275]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75276]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75277]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75278]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75279]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75280]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75281]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75282]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75283]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75284]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75285]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75286]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75287]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75272]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75273]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75274]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75275]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75276]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75277]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75278]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75279]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75280]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75281]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75282]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75283]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75284]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75285]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75286]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75287]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75272]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75273]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75274]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75275]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75276]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75277]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75278]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75279]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75280]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75281]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75282]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75283]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75284]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75285]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75286]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75287]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75272]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75273]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75274]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75275]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75276]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75277]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75278]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75279]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75280]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75281]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75282]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75283]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75284]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75285]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75286]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75287]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[121] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[122] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[123] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[124] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[125] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[126] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[127] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[128] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[129] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75272]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[130] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75273]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[131] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75274]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[132] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75275]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[133] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75276]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[134] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75277]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[135] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75278]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[136] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75279]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[137] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75280]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[138] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75281]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[139] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75282]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[140] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75283]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[141] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75284]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[142] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75285]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[143] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75286]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75287]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[146] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[147] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[148] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[149] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[150] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[151] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[152] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[153] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75272]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[154] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75273]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[155] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75274]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75275]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[157] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75276]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[158] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75277]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[159] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75278]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[160] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75279]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[161] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75280]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[162] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75281]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[163] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75282]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[164] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75283]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[165] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75284]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[166] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75285]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[167] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75286]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[168] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75287]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[169] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75264]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[170] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75265]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[171] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75266]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[172] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75267]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[173] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75268]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[174] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75269]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[175] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75270]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[176] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75271]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[177] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75272]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[178] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75273]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[179] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75274]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[180] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75275]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[181] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75276]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[182] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75277]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[183] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75278]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[184] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75279]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[185] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75280]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[186] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75281]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[187] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75282]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[188] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75283]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[189] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75284]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[190] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75285]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[191] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75286]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[192] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[75287]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[75431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[193] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[4] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[5] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[6] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[7] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[121] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[122] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[123] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[124] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[125] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[126] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[127] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[128] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[129] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[130] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[131] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[132] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[133] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[134] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[135] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[136] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[137] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[138] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[139] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[140] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[141] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[142] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[143] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[146] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[147] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[148] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[149] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[150] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[151] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[152] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[153] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[154] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[155] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[157] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[158] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[159] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[160] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[161] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[162] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[163] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[164] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[165] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[166] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[167] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[168] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[169] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[170] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[171] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[172] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[173] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[174] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[175] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[176] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[177] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[178] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[179] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[180] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[181] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[182] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[183] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[184] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[185] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[186] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[187] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[188] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[189] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[190] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[191] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[192] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[193] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81408]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[194] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81409]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[195] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81410]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[196] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81411]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[197] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81412]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[198] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81413]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[199] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81414]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[200] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81415]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[201] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81416]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[202] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81417]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[203] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81418]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[204] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81419]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[205] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81420]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[206] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81421]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[207] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81422]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[208] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81423]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[209] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81424]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[210] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81425]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[211] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81426]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[212] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81427]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[213] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81428]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[214] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81429]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[215] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81430]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[81431]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[81599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[217] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[4] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[5] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[6] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[7] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88320]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88321]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88322]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88323]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88324]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88325]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88326]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88327]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88328]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88329]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88330]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[88331]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[88427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[4] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[5] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[6] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[7] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[8] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[9] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[10] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[11] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[14] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[15] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[16] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[17] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[18] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[19] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[20] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[21] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[22] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[23] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[26] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[27] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[28] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[29] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[30] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[31] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[32] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[33] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[34] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[35] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[37] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[38] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[39] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[40] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[41] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[42] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[43] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[44] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[45] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[46] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[47] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[48] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[49] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[50] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[51] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[52] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[53] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[54] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[55] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[56] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[57] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[58] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[59] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[60] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[61] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[62] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[63] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[64] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[65] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[66] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[67] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[68] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[69] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[70] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[71] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[74] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[75] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[76] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[77] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[78] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[79] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[80] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[81] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[82] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[83] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[84] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[85] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[86] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[87] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[88] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[89] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[90] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[91] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[92] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[93] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[94] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[95] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[97] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[98] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[99] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[100] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[101] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[102] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[103] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[104] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[105] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[106] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[107] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[108] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[109] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[110] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[111] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[112] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[113] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[114] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[115] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[116] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[117] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[118] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[119] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[120] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[121] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[122] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[123] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[124] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[125] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[126] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[127] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[128] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[129] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[130] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[131] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[132] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[133] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[134] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[135] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[136] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[137] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[138] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[139] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[140] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[141] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[142] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[143] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[146] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[147] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[148] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[149] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[150] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[151] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[152] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[153] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[154] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[155] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[157] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[158] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[159] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[160] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[161] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[162] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[163] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[164] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[165] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[166] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[167] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[168] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[169] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[170] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[171] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[172] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[173] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[174] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[175] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[176] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[177] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[178] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[179] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[180] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[181] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[182] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[183] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[184] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[185] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[186] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[187] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[188] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[189] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[190] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[191] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[192] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[193] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[194] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[195] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[196] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[197] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[198] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[199] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[200] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[201] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[202] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[203] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[204] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[205] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[206] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[207] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[208] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[209] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[210] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[211] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[212] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[213] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[214] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[215] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[217] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[218] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[219] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[220] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[221] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[222] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[223] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[224] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[225] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[226] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[227] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[228] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[229] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[230] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[231] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[232] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[233] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[234] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[235] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[236] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[237] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[238] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[239] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[240] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[241] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[242] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[243] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[244] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[245] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[246] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[247] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[248] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[249] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[250] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[251] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[252] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[253] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[254] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[255] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[256] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[257] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[258] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[259] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[260] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[261] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[262] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[263] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[264] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[265] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[266] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[267] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[268] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[269] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[270] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[271] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[272] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[273] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[274] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[275] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[277] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[278] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[279] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[280] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[281] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[282] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[283] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[284] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[285] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[286] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[287] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[288] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[289] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[290] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[291] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[292] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[293] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[294] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[295] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[296] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[297] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[298] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[299] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[300] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[301] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[302] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[303] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[304] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[305] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[306] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[307] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[308] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[309] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[310] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[311] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[312] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[313] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[314] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[315] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[316] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[317] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[318] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[319] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[320] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[321] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[322] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[323] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[324] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[325] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[326] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[327] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[328] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[329] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[330] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[331] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[332] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[333] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[334] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[335] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[336] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[337] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[338] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[339] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[340] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[341] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[342] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[343] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[344] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[345] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[346] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[347] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[348] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[349] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[350] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[351] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[352] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[353] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[354] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[355] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[356] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[357] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[358] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[359] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[360] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[361] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[362] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[363] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[364] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[365] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[366] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[367] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[368] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[369] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[370] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[371] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[372] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[373] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[374] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[375] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[376] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[377] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[378] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[379] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[380] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[381] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[382] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[383] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[384] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[385] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[386] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[387] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[388] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[389] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[390] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[391] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[392] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[393] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[394] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[395] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[396] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[397] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[398] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[399] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[400] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[401] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[402] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[403] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[404] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[405] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[406] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[407] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[408] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[409] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[410] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[411] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[412] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[413] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[414] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[415] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[416] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[417] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[418] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[419] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[420] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[421] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[422] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[423] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[424] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[425] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[426] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[427] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[428] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[429] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[430] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[431] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[432] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[433] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[434] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[435] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[436] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[437] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[438] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[439] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[440] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[441] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[442] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[443] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[444] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[445] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[446] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[447] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[448] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[449] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[450] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[451] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[452] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[453] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[454] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[455] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[457] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[458] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[459] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[460] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[461] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[462] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[463] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[464] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[465] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[466] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[467] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[468] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[469] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[470] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[471] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[472] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[473] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[474] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[475] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[476] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[477] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[478] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[479] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[480] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[481] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[482] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[483] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[484] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[485] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[486] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[487] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[488] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[489] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[490] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[491] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[493] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[494] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[495] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[496] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[497] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[498] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[499] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[500] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[501] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[502] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[503] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[504] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[505] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[506] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[507] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[508] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[509] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[510] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[511] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[512] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[513] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[514] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[515] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[516] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[517] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[518] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[519] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[520] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[521] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[522] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[523] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[524] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[525] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[526] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[527] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[528] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[529] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[530] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[531] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[532] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[533] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[534] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[535] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[536] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[537] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[538] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[539] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[540] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[541] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[542] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[543] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[544] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[545] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[546] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[547] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[548] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[549] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[550] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[551] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[552] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[553] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[554] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[555] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[556] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[557] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[558] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[559] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[560] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[561] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[562] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[563] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[564] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[565] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[566] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[567] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[568] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[569] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[570] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[571] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[572] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[573] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[574] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[575] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[576] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[577] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[578] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[579] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[580] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[581] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[582] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[583] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[584] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[585] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[586] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[587] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[588] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[589] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[590] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[591] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[592] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[593] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[594] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[595] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[596] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[597] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[598] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[599] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[600] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[601] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[602] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[603] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[604] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[605] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[606] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[607] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[608] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[609] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[610] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[611] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[612] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[613] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[614] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[615] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[616] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[617] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[618] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[619] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[620] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[621] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[622] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[623] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[624] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[625] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[626] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[627] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[628] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[629] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[630] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[631] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[632] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[633] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[634] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[635] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[636] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[637] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[638] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[639] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[640] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[641] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[642] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[643] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[644] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[645] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[646] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[647] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[648] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[649] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[650] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[651] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[652] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[653] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[654] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[655] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[656] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[657] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[658] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[659] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[660] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[661] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[662] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[663] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[664] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[665] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[666] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[667] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[668] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[669] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[670] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[671] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[672] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[673] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[674] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[675] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[676] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[677] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[678] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[679] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[680] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[681] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[682] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[683] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[684] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[685] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[686] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[687] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[688] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[689] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[690] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[691] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[692] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[693] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[694] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[695] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[697] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[698] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[699] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[700] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[701] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[702] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[703] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[704] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[705] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[706] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[707] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[709] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[710] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[711] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[712] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[713] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[714] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[715] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[716] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[717] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[718] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[719] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[720] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[721] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[722] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[723] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[724] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[725] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[726] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[727] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[728] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[729] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[730] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[731] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[732] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[733] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[734] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[735] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[736] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[737] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[738] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[739] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[740] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[741] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[742] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[743] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[744] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[745] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[746] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[747] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[748] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[749] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[750] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[751] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[752] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[753] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[754] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[755] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[756] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[757] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[758] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[759] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[760] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[761] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[762] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[763] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[764] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[765] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[766] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[767] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[768] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[769] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[770] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[771] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[772] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[773] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[774] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[775] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[776] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[777] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[778] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[779] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[780] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[781] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[782] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[783] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[784] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[785] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[786] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[787] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[788] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[789] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[790] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[791] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[792] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[793] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[794] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[795] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[796] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[797] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[798] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[799] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[800] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[801] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[802] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[803] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[804] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[805] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[806] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[807] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[808] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[809] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[810] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[811] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[812] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[813] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[814] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[815] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[816] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[817] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[818] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[819] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93024]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[820] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93025]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[821] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93026]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[822] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93027]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[823] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93028]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[824] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93029]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[825] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93030]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[826] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93031]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[827] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93032]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[828] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93033]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[829] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93034]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[830] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93035]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[831] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93036]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[832] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93037]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[833] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93038]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[834] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93039]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[835] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93040]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[836] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93041]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[837] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93042]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[838] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93043]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[839] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93044]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[840] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93045]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[841] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93046]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[842] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93047]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[843] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93048]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[844] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93049]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[845] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93050]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[846] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93051]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[847] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93052]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[848] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93053]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[849] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93054]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[850] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93055]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[851] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93056]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[852] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93057]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[853] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93058]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[854] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93059]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[855] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93060]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[856] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93061]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[857] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93062]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[858] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93063]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[859] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93064]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[860] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93065]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[861] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93066]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[862] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93067]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[863] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93068]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[864] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93069]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[865] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93070]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[866] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93071]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[867] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92160]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92208]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92256]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92304]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92352]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92400]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92448]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92496]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92544]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92592]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92640]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92688]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92736]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92784]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92832]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92880]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92928]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92976]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[868] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92161]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92209]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92257]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92305]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92353]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92401]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92449]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92497]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92545]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92593]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92641]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92689]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92737]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92785]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92833]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92881]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92929]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92977]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[869] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92162]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92210]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92258]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92306]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92354]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92402]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92450]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92498]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92546]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92594]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92642]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92690]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92738]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92786]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92834]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92882]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92930]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92978]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[870] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92163]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92211]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92259]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92307]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92355]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92403]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92451]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92499]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92547]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92595]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92643]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92691]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92739]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92787]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92835]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92883]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92931]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92979]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[871] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92164]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92212]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92260]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92308]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92356]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92404]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92452]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92500]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92548]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92596]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92644]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92692]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92740]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92788]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92836]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92884]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92932]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92980]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[872] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92165]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92213]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92261]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92309]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92357]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92405]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92453]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92501]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92549]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92597]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92645]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92693]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92741]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92789]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92837]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92885]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92933]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92981]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[873] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92166]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92214]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92262]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92310]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92358]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92406]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92454]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92502]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92550]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92598]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92646]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92694]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92742]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92790]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92838]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92886]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92934]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92982]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[874] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92167]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92215]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92263]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92311]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92359]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92407]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92455]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92503]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92551]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92599]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92647]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92695]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92743]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92791]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92839]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92887]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92935]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92983]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[875] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92168]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92216]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92264]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92312]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92360]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92408]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92456]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92504]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92552]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92600]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92648]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92696]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92744]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92792]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92840]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92888]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92936]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92984]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[876] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92169]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92217]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92265]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92313]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92361]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92409]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92457]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92505]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92553]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92601]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92649]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92697]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92745]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92793]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92841]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92889]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92937]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92985]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[877] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92170]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92218]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92266]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92314]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92362]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92410]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92458]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92506]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92554]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92602]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92650]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92698]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92746]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92794]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92842]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92890]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92938]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92986]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[878] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92171]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92219]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92267]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92315]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92363]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92411]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92459]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92507]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92555]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92603]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92651]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92699]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92747]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92795]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92843]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92891]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92939]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92987]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[879] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92172]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92220]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92268]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92316]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92364]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92412]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92460]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92508]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92556]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92604]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92652]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92700]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92748]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92796]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92844]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92892]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92940]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92988]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[880] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92173]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92221]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92269]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92317]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92365]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92413]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92461]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92509]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92557]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92605]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92653]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92701]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92749]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92797]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92845]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92893]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92941]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92989]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[881] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92174]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92222]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92270]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92318]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92366]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92414]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92462]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92510]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92558]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92606]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92654]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92702]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92750]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92798]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92846]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92894]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92942]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92990]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[882] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92175]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92223]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92271]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92319]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92367]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92415]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92463]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92511]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92559]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92607]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92655]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92703]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92751]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92799]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92847]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92895]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92943]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92991]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[883] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92176]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92224]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92272]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92320]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92368]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92416]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92464]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92512]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92560]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92608]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92656]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92704]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92752]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92800]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92848]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92896]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92944]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92992]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[884] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92177]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92225]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92273]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92321]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92369]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92417]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92465]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92513]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92561]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92609]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92657]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92705]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92753]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92801]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92849]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92897]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92945]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92993]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[885] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92178]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92226]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92274]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92322]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92370]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92418]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92466]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92514]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92562]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92610]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92658]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92706]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92754]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92802]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92850]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92898]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92946]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92994]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[886] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92179]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92227]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92275]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92323]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92371]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92419]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92467]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92515]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92563]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92611]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92659]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92707]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92755]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92803]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92851]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92899]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92947]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92995]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[887] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92180]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92228]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92276]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92324]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92372]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92420]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92468]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92516]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92564]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92612]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92660]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92708]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92756]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92804]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92852]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92900]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92948]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92996]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[888] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92181]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92229]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92277]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92325]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92373]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92421]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92469]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92517]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92565]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92613]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92661]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92709]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92757]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92805]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92853]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92901]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92949]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92997]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[889] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92182]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92230]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92278]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92326]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92374]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92422]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92470]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92518]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92566]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92614]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92662]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92710]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92758]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92806]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92854]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92902]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92950]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92998]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[890] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92183]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92231]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92279]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92327]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92375]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92423]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92471]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92519]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92567]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92615]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92663]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92711]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92759]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92807]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92855]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92903]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92951]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92999]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[891] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92184]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92232]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92280]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92328]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92376]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92424]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92472]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92520]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92568]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92616]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92664]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92712]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92760]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92808]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92856]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92904]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92952]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93000]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[892] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92185]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92233]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92281]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92329]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92377]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92425]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92473]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92521]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92569]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92617]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92665]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92713]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92761]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92809]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92857]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92905]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92953]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93001]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[893] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92186]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92234]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92282]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92330]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92378]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92426]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92474]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92522]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92570]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92618]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92666]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92714]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92762]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92810]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92858]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92906]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92954]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93002]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[894] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92187]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92235]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92283]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92331]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92379]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92427]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92475]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92523]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92571]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92619]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92667]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92715]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92763]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92811]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92859]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92907]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92955]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93003]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[895] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92188]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92236]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92284]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92332]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92380]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92428]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92476]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92524]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92572]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92620]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92668]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92716]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92764]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92812]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92860]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92908]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92956]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93004]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[896] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92189]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92237]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92285]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92333]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92381]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92429]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92477]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92525]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92573]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92621]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92669]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92717]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92765]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92813]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92861]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92909]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92957]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93005]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[897] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92190]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92238]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92286]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92334]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92382]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92430]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92478]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92526]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92574]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92622]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92670]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92718]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92766]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92814]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92862]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92910]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92958]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93006]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[898] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92191]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92239]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92287]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92335]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92383]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92431]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92479]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92527]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92575]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92623]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92671]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92719]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92767]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92815]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92863]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92911]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92959]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93007]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[899] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92192]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92240]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92288]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92336]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92384]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92432]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92480]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92528]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92576]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92624]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92672]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92720]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92768]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92816]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92864]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92912]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92960]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93008]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[900] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92193]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92241]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92289]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92337]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92385]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92433]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92481]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92529]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92577]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92625]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92673]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92721]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92769]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92817]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92865]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92913]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92961]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93009]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[901] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92194]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92242]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92290]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92338]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92386]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92434]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92482]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92530]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92578]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92626]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92674]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92722]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92770]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92818]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92866]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92914]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92962]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93010]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[902] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92195]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92243]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92291]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92339]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92387]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92435]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92483]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92531]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92579]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92627]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92675]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92723]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92771]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92819]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92867]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92915]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92963]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93011]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[903] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92196]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92244]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92292]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92340]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92388]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92436]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92484]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92532]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92580]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92628]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92676]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92724]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92772]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92820]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92868]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92916]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92964]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93012]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[904] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92197]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92245]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92293]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92341]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92389]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92437]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92485]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92533]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92581]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92629]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92677]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92725]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92773]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92821]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92869]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92917]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92965]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93013]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[905] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92198]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92246]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92294]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92342]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92390]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92438]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92486]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92534]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92582]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92630]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92678]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92726]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92774]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92822]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92870]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92918]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92966]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93014]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[906] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92199]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92247]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92295]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92343]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92391]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92439]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92487]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92535]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92583]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92631]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92679]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92727]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92775]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92823]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92871]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92919]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92967]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93015]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[907] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92200]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92248]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92296]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92344]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92392]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92440]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92488]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92536]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92584]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92632]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92680]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92728]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92776]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92824]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92872]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92920]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92968]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93016]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[908] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92201]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92249]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92297]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92345]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92393]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92441]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92489]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92537]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92585]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92633]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92681]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92729]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92777]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92825]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92873]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92921]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92969]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93017]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[909] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92202]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92250]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92298]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92346]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92394]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92442]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92490]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92538]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92586]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92634]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92682]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92730]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92778]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92826]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92874]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92922]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92970]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93018]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[910] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92203]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92251]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92299]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92347]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92395]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92443]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92491]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92539]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92587]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92635]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92683]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92731]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92779]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92827]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92875]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92923]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92971]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93019]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[911] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92204]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92252]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92300]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92348]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92396]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92444]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92492]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92540]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92588]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92636]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92684]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92732]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92780]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92828]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92876]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92924]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92972]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93020]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[912] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92205]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92253]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92301]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92349]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92397]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92445]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92493]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92541]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92589]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92637]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92685]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92733]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92781]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92829]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92877]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92925]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92973]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93021]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[913] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92206]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92254]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92302]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92350]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92398]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92446]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92494]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92542]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92590]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92638]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92686]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92734]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92782]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92830]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92878]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92926]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92974]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93022]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[914] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)&cnProcBuf)[92207]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92255]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92303]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92351]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92399]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92447]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92495]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92543]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92591]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92639]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92687]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92735]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92783]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92831]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92879]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92927]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[92975]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)&cnProcBuf)[93023]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[915] = _mm256_sign_epi8(min, sgn); +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h new file mode 100644 index 0000000000..b3d7c337ea --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h @@ -0,0 +1,4 @@ +#ifndef NR_CN_PROC_BG1_OPTIM +#define NR_CN_PROC_BG1_OPTIM + void nrLDPC_cnProc_BG1_Z384_13(int8_t* cnProcBuf,int8_t* cnProcBufRes); +#endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.c index aeb8505f53..ffb9f2343a 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.c @@ -8,7 +8,7 @@ #include "../nrLDPC_bnProc.h" #include "cnProc_gen.h" -int main(int argc, char *argv[]) +int main(int argc, char *argv []) { //short lift_size[51]= {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384}; // unsigned int errors, errors_bit, crc_misses; diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.o b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.o new file mode 100644 index 0000000000000000000000000000000000000000..a3dbeddd6b3dc7d1fe13e358ba11ce497c075b94 GIT binary patch literal 206488 zcmeFa37lqCdEk9-?NwdXU0uEJ`@U~9-7MWSG&Ea7H~S*{E;hS@A{HQm3J9X02#6qp zhE+ubca6J7gE7(Qn3!?N7?UxHt)tqT+B(}>J3Bf@ zb+mSLbhWmP>TGUli5#7ynwpzwthup;z;AO4Ew?l_Hbi=JQ{zyfp`k$t+d5jtw*yAj z*6MGb5g+9yPU>iG9^Km2($?PH-kD{iyBnICT3Xs@q^r3#%UYTn8XKF^A817xf0t%i zo;Nf#=A;dvR4yai^XA6ZHgoo2vbU9xH%=Hjp_0CkGxCu)P#YPei9RKIz#(srh`s4W z<(wNEn;R)ReAq(rc6fOd#~B>AaXd-fOB}!BdQqPBUPdK1b39e6vf-N=Dz&$ZHo8e! z#IcF%*Kj<~^;aUdlHA+D^~D^QMO>fXExlW_ZNPtI?=jh~?4;h)de6?z?LDtgj$top zeN6AfY+CPv-Zj}eTFSGQ-USJkq8u<~J2-ZcdK$-t95->?&G9JlFK~Q|<7XVruYf-G zr4JviImduX$T-s!!wvN^qrv!%VuvK756BOk4{!=(w?J zH>Q~ObUi9-C#5OH&>grg@;9ezMW-{Rj?YGOJvp1mZ{%;zR4i>NwJWRUpP8x2mL?KU z&Q_=Vv-s^w`Nwn4vN=QKKbH8(nZma7!t+e0Fud>oYyG@jBEy4K za!P1Bf1@ZkDp8|W4RWkM*X2jVMSmK;1~Jb$EM<@J-Wd5`PkH;6c;^Xg)Fbyz{I(J| zkS9Yy(g~iUs6mLkXi+M(Bzi=j9jZ*mM4jdHo|w?&SYsN-wPNe^E9GIxeZ3|0{X02mj|ovDsX&0P`^)A17q1kj4F~)sgWFj@c(j3UkLxN ztnmM^>{X?$RuiT`tr<{%0{ov&$r;FRL*hrh{GWlej%7I9kj;f_1^*{gM?Ly)E#sZp z49^SxACw)!NJsv!+^8c>vDr&lczuMuu ziT_t-pUm#azLfZXUG{YLwh{6F2k`$1`rlpr84CW#-S9A+mTk#b=d<(O*`fKbv%gRM zzcUa1J0hAv$t}6U-m`de>c~U*Fv83FJ@hN!2iX5@b8=d zWnKEiCaNR-xQg*?^*2q5D!GQvkyjv%)M}m8I)+QB)?d_9sjlu*F;}v@qpz4xS#R7$ zOpMhdEv{`K$~yjyQG3J$C8ka#^97137!RqOtHo`(wxJKkKA!IBkazpjSq_3o*Xg1dFz|=r$#G3a?jGi zS23|h&$cW4UOSrB!enX(*UtHj?Ieeze{+jx%%Fs26mbot3#s`WojXTTYLpc%2IAUD zx^!rvgcy!ANaaq(?b5fIa~HMQ_9*J^pw(8cOf$w@O=*Ouy+Mqey-Qg!b0%)D=;ACM zt^9SQ*yv5IsqUN-&J&as`I&Ji49?pu`$~dRDgB~O>8NysJ_&sjvZ=&|_A@r}L@rZ` z@>~*(_qWIw8pd34WofVcGhdOHi&qe$_l7o8>V?I)&_PPQ+D3YLD7&Ua`{oV(6t*x^ z15f48Qp%<=p`}8HMcqL++x5!0kp}q|?I{HTi=1yychNJfQ*0XHy@$D4lH@2m=2iCW z<@Ud@qY1HC+q1-0tC&4T$yeT`lJYJc#7#+!*0~))P-g8{VR=(x?R6oy%6Qn|>}_pH zvYTkfIkN2vvCs;m^pg_ym*UD^BG!dIQu6Irwh%Tedx|*Os=QbFXfa&RyioiRn%h)MnI4x$(51ozwY$=znvyk`nrV9OXuFSLpv9YE_SoqdhHr zUEFIu3;o|ksgZ^r>S_XN^ikaQ1i=ov97o!8W*$=#tP?qRa@Ru}#E`qvh$+qSJ|q`^9sVb5wapR-Cp=sLBGV*xc`Xvv(rcH(?WtG7b?n%fk0yBb!# z75d+P zKaRh!*xF;ekaYX!Sa6XF>Kmmb`e!$J?c?I1uF&3S|NZys|0&dvBj<(wpG>_|k;SP% z&`Eru|EB`Gx}=Ampq5gmwNXz1F8i~TZ3n^$NVo7caHZ^LN;L80oI?LErbhd3 zq5l_g*H`~91n$|iy9Qa9$?pnQaXZm?q5r3H)lI6k6#9P&=@YQ+H?z91ienn<%+s;$ zFQJw3+>a;sI`CRX{A{pYnWS)J90>itjPmQT9ZUal)V~fY<=Mt;1F(*w?a=?`Qva_7 zu1%~nOaqV5|FeK-6FJua(`MvjBQmz0vQvP5D$va%rIi%*|3YGM8z6QTm}TIwm{P7@ zyfXdoJjmYX=us`=6EgI_BPzAhXwr*$l=@J8tEN|@IvQx?P=^)z-?^5f(k5y$t+|p* zZRSYC=dUXz%KR8|TDSV&x<(p8|Eqr-&xHQBogVatx^FDkK7rM<^4o>wo*IdP+DQWwdbLooaGMGl7)Q5wBGLyV~UQeQs2JxAW>()L{HDD?k6V59zD2)r5cyALfaA+85WUc#aNUqOip z^p2|jUrx#fWM2KhhVr5R*8rsyo)30?_5V!nq(Y4UH>MIJg7)uTA8|Bu0asfAzt9v%OO{@<6B(Empx)rXK*{l6Anaxh#R zlN|vc`s)7;K&<|kug4@=T8XW`i+jfxhr-=9;{QGR|8#iXSO1^JUFiSKQ2huvt^Pk5 zE*JX$tZXaNbtJrV#Zvu$G7yIT-$LB0NIyI~1I!j?=W3OUiP0r3q{d;8epTdgEG-{a58rE7`yAUcY!HG`&e^t`|hxOC{$3VwDQ0y8gcM>oh z0(V+jb!#C;{eNusT5uVt|IZ}lVD$enNY6Q}j$MfR+NG2_2)>=i-@ixyt5ei#&LCz1 zT?4;W{XYq)M#Jwm4lP~IGP}Vz^uMX<{~6HLS;!{`Yz3Y|LCUNpV%#r(KLE z)N<+!+mE_NMt$A-Ci6FmbD{s|!RgsZ%n}au|7==cl60LIEFf>_|5eEI9Qxf<`sqw^ zbit?TlxPHl9^eX(k{JIlBS!u2tZgwpXC^(koBWQETze1wKbe$~h8X`B`u{*=Nd3Qx z)()fABan|HfM+cdF%xMz1n3VTemuQ=Cwa!PdbkP+I+*kgK(v#b>i=!PZ;##x+*_f* za?-}35vHKk4yMK#q%@#y=8&Rxo4{y7J?waJWMKn+F3(;K=IZ|~$gk^Y$0FmQ|IeUj zWk~8iz)|S`vytW_kmMD}|Ix^D=>L6@=JSy24M_Mw$od*ERsSE()&ArO{l6i-=j`u|k&h5mmF5JWha(~ioui~HZMQ2&25 z`#|rGJe=Jb^KD!keQtbflc`*)E4PiLPY^?UGM{r_QbQvW~0D)5s) ze0LiEKau?fec)5sN2&XHp!_zisQ(D#f=r4ySt)l+l4Ci|27lr=cjh;Of**i1o|0DM5{~c()k%qCr)|s^B zG_+(@|DTHlT#(%lETR8zCC@GJcM^ws`nK#L@ae1nZ=v@+L=V0O+1SPiOcEqPZe{$={v53n}HN`B;w zm-0gY|1&9t{(m3WzX#jC`u{PD67u{pUS*h&JN|zP-aSIyS!z9lYcFJ@^O2ALC+9uc zqcMgRXB{xzZhm*nku+-%KXrg#2v)|RXPf1CXp&2kxj zEQ_;$My@C2yL0vbm*|;)nnn~GvIY4Sc(xS!|IgrX=>N|A)4aseopx1A|%U z(rf=f`se-7{Q~s-LS(at=ZgC0iW2?vF8toEL(X4?Ourd@qW<|@(m(ek{qqdZ0!K9$ z^IX3_dpq*|XwpB|((|kO=VD+F{c|zB|A|+if1byq9;F}T~F_C z%=gbj|NM&Q#jQyH57YQ_M*c9e_g&h&ARG9KS8YMsidLJ1oc3lX(r3@i{!@~l4!IvD*(druzpg_Qyg$j$qW~Ip)rPo#j^g?C6SPLi&%yaGGJEHXym&TPetr&& zUuQPb-GAyloUU3~tX{S^no>lh zn9p3UMzwI|x>#5^w8Dk2LCTWi10sDCge!0xygp_-?75mIKDK6xYu;LyUD+BOtVcf_{nfP@ z2UWG_YEufXxXy1oT8v{AJ-o~U)6SG)OF@mkZMbIVpX7DmN+|!@ zyIlK|7L!uibbh^d{UqeywZGBiQT_+}7f4}iiWPrx6XK9sz1mzyDdb-|74jckw#Uk| zLNgAA-hypqqg8?j`h^D8X7e) z%bW|0D?wXJ$GjBNoUVJY4>U82)5ciH|9tWf3?cvOG-Xm*5MpIg$qV^ci@DD0Dyh<_ zr-@!j%H?SC74om8ePHmdOxOREPBokoI)>{Byppe^*oo23N54 zm}q0pKbgZ7wSD+&A$}ZIp>DV~n?G&o>r*b}e-`zxWY(el>mLyE@4ETGFowFK2d~Mt z0*ms0P(}V%GAk+MephKHit*1f)~k-K$p4AZImbFS z6U)|t(D*E%2>CyRJca!4O!9vcxz42Zf#E#n23z>^4Y{MC^FbV!lk-yG4EaAEi|PLG z{y1WdX~t5d{$E92<^KfeJDQnk2kj4*e>IO!c4zTZfNpZqSIWO$Y!itcier7(J>|1m`RX4mHJ)CYBPYuLoFtc3`JYNlbFf;p(eh&Qg#6DZSIGZd z()A<>`BxVEhefQODF0iTKOKX7`WE8B$VkZlVkoDl#X9a6!}pN?b>y9iG%ZW=zklNN zk|h62`d7}~F64Y)_}0d3^H}QNmsQ&W^T(d?3mHJy_DUf1knmYN)OJzXM6zh2>&2 z@yh>ehG=1+{NIDU{*!y<|BdkdVM;!ZMNRqt9J2Cy#x5%}C*5>{NRI?<#7&gR7gcE~@`;2fkau zxC0r!ZXo!;c0aIvHOc?yll*^>vdaI<)cRnO|F5y?Vc8!8#SgKzZlTq$V3SyzeW4=% zFH!yl_;mfC`hSV->b+Qg8Sms}T1`d=JvmmVbm+kIMf$_D|*i)ck)U|3~ImV?}Dne+w3~ zbLIcD$p5#J{C|S?eI}cnugaC5d3hl}4_D-8bbeDdE&mkq zvmAOZ%0qspz@h%(xxMtc4@>3c+5dnZAH>>qI4cO!=f1u4`62ZAHT~QE^*(IKtB^10 zb3fd@C;Myk$RAa-j?sk{|@Nq z<8t3HL&`A_aYZZ%%I~ptOeC;i+DGP6#eR|-Z%#` zcSDLQ?uyyEb(vy(q?s*ZQh^#jg#|}Df}x3{uvw)D;sa8Doyi0&MQr3L|8;&PG+KYG zTX?;;yeVNL^FFLs=JLu>c0Iuvp~3O75c-4&>N*p3{uw!}(;974Or1y86P#fNPR-pl7W%9N+6Luh+SAjIgA|Ji~fC42@}QAZB{IJN^&6YuB&u zyfYT(2Vr4zPNGFAY;MxTS&h~iA@E%g?L7r{wOc4;QAreQ=VM+MH1IxRVkTs+BCS^K z%0<`}qHbkeDHQ5xDdZ(AAB7D}jureEz6ER3Ht1m)=XlD7HU~q{#&b|lPK%oqt0%~} zLjJW|X4;ujJJJ4 zu4=WRWh|_s+C_XXNUtm9Uq4^>7LxnEp;XX&EcJ^`eeyqsF_aV?OPMK*)5misCmjDY z@^sV-*HD%J$v`lLHk}LB4r3XAh5S!V6u0yY+A8GVTJ((UrcUL5BI&*x1@~{8*j&IPY>IdmNKo8N|@4Bzx;PX z=XP)o`PcHG71uXkv{h)83EdF#@4H;SVdh-AKKYdXzUQJx<`imH{^jvxYW9s4cY>Of z)TfK1TACp zQpqvQLze*AVrVc8$|(PHpn`stdebQXwy+3{W&>4y@GqfE$iLp(;~CS2{A-t(!Puvp zLwjO>`CkW3wQAK4V;P+*|BI+&7MS#v|HZ(m&14>P3Fndv`^mpEpV}d`n;!YD(!>gY zG;ap}910neef6ZznwYm(ZF_2lK=J0>PAy* zA^$s(PM?oCG&~Ax+=XzsKKVbIIl{KR@_%NM|5K=;iJ8NBP-PD@`!kdLUq#zHz@`Tb zkENCRkky*PVC<)f4W)yYNu!=C}#3l=s8Y zi^v!9{~dT;zx=<1U1brF--iY4E-YVv3VpAq&L1QHzrZ$jCar&nnXmGH=ZNKhF17en zT#n2yg&wn!_CV4WUHza>y}JQ!h9?W^lpp2)XmHhXyAB@io8(^)sjB>+lH~tP zq;x;p@1egR0kw{K|HD{tehQ`^!LF8LlX;2j`>E-- z*}r1f`D8XKzYnS_|G&!qfwV)gu6!L|sgcV6vq1H)Snsywr{{l-{=XAH$1!*n{jwte zdN4l=<)4Mqqw@OY|8yuh8*WzR=d6nS?8E{$i?rF;dP06K0h1%aMENFsDq0i%B_^Uqj z`8jRX6AJqLBlI~ge+m0rL$-h3lS`kMv!nCN@OwW6zrVTpoAR~UX}R<{C%1of<@MCB z#Ud;-ab=kzrYP?dH0%Z14C1cH9d-lboI7cK(gNUBgs?3*3k&-|*r;M3g2-V_js?SZ zWiD+TVKH)s<80W&6jxKttvx@+kFM1F27j>wfuj&-WRBzvLKg3*I0g{2fVDUm_*=Vm z8E@-xUCajqe`k;}&kHLX*~sVEwy<#toh=J*gz!^v?iV{H75MAtWUxemzkVnK@%N2& z_sI}{SB1sZ)n?~r2H|wQ*>?qf1JzNT_&ZZKIQRFRes?H|^IETS_;I!7(MxRn0w5M|723!?O8vED*mn* zIx2J5Sn&`43r7qF$Jt9MHH*@Yx@R$-Sjh9Fz+caX)x;F|+iUydzXDCPk!MEWKQo(6 zjujlMID{j-0)p;(J&Xogts_; zJ6Bf4e;&0v($~XcPRg+Y*nB6>ebW!-Y9XVa)>OJL{+rROlgV)s`0qqJ92YT5(^cI@T9_+Pab|5IsyfAHU*cZdvC{N3SXB9M*d>ETW%j;VtGRs2_h z|8nqI*$@BqK)#m0o#?nF@Za|_9oreie?Ra)5&Vw@|3ef0$CK}rlzvSG{~bKn-wytJ zSOYs|0RA^IHWL4L@^pS3Bca_q0bX5^{}<8N=kaWw%qUR&zr*wA1B@+qRMx5*!1a$3 z{%>JDC`V_$hY{6d998_61C2Yw_y(}}?+10(?ZtmJF~R>sq2ikK&gx3W+`<3jX!FfH zxz+;zL%=TnuLl3uF^({NZ~*?F0RNkq!MvBJyrDVY$ZFLj;O)t$v1;?bd5=K+@2bfE zkC6YHc&h&|*66n7XXcCY5Akf;P2SI^@_H3qN~_!OAGk2VzY|Ja55@)mg#QBW+n}8A ze;VBGWaaOwR9^V!=fXcXKM-H#ud_lmDqqGM2$OR&e4F}zP5ob_{$DcgnGToVfUk5> z|Ci`}ee3_nRR7MrsK0nls6mTsE3V!pFiL+yBUej$p8!iGs#j$d#8X9mroBo1;t@Jt zU0f@K{jh2)SG!nR9jV@|6`ZyC1S+0sYJDw$u2K}wAaj%j=aZpn{Z;Gg>8F2(nmAI* z${KH5T6XldQhU3a;XXTh_tuBM?U`F2u+ZbNx}mRbZ5wqwRfB8NKc27Bv%VDuOBQ~M z!N1_7nyEU|Fvzjefb|AWIjKAy6cfP68?`tN9vpA94YwURT%>ehk+h#jxQ#mkAnZ| zcgGy^zqSoYiYbGRom?x5@kMy3*JEMV%QW~Oo_nqY$qPp*_zw&RdP*z!@7Tz1o5ap_ zS|PQ1*5U&8EyWe%Eu1g#WP* zo}6@iHJY;SND#eaIQseQ)k{~+ z>1iqdO&LBE{NFF}e*^qKyTbqd@o3sUd|^`c$qW9U$T;hKMn7X2g`N)oPlui-)GY7r zPr&Sm8P4F1$awSr^)u}FOm)yBXF-+(UoKZm(Mt+0l625)+>hVixmZJ^*@c-L2%Wp)>Oibg_6^Z}r_wwHnbZ!2h$awRh3jepj|I?Y> z9FY3IZ^`ej+5U}*|Ht!or2YQ}_KLr0@N4r*z6p zvxw?l6%I!=QG-wTfin!BfX3;+V+~;is+Nwc@M@|0ELGDTi&(4UD31b~B8T>%@IlgE zqqV4i5F_8Ci~Zt;egYSkFtHd|zqYEvJ~kBoks5FMxHd2tf5**^zhf>@j=#PQqx%ET zo#U~<-*5H|#@{!y#NV}N$6AB&*B;iz6TsEtq3{F+U{=qSd z<7D60690i1=m+n9i-EtpKK2hjEu8T<+7|z~ujW~t#xL?e@E@o_#b2-B3VtvX#jPuq87e}$FjZl3M$ z9fbet3jPb>!V35_82{rKH3t62@p0&ZUX`+g86!*nd z#8-1ieB>?CiZaz2i_(!&)IIPVwV1aWs&#m!^(M~dh$mpRHFcrs{#Ik-zN#mErub)$ zB6mDzB2N{n>Qw=mG5v$js<0#YJT0DFJ|UuAOKLIF0u=R|&%sQr;Xxgi!mtPWma5Rk=uqf_F5(eyK`TpAG^EeB7t2FXPwQ{++PY$uON^zg zyF+Sc^c_fH*XAPhQq-}G@P-F=@Y5Q_%N){L4D=|D(U>cH;w$xId?d94gZL$JZwOr= z->fGzg1N-d!{3kCbl(Uvl6u(yOgRam13hrQMQW8KlO3jJqna5gv^^(Y-dx%ef^-ryM0 zHzMSTnnkH`J=AOav{1*_GJ+n$tXv7N_Bz+@Z7b$I(pP(oa%j)*;;fwcZ3$N;q+{?v zEZj@m9yOf)bBs5<{?mWoJ{7dcixp2d$2S#&eaKX zPTk6s_BwB)cVJcYboji?HzZl{! z3S)>><0*PjV$XdSvLC&^^kwD=fufkB*+JR#F}vfk;jJh5gw2qHcS4X!Ouvg%tKBqi|S0 z`fgSK$suLaG;1@5QdK;CgYVYp6GFYC6uV~Q7{ghx{aqVH=o_Ey@$`$jqR+a{W*wnz zhJvqHMR2ZI)qkNg!pB9g)7ZVieYM?-!L|NE|Jj2A7HQkbg5M3%FWxt6v>p`tPswuSL(iYl zq}^8GLFpckyw&w1774?GwmvsOrBp>0Zl=!S@TKl3&FL z{ih$g>v3y2XRI&G18K_sC{r6KTPEp}&rE|9y!m^xu4PS&RBlE`|R((Ki_dw!j)P3VmuRlFD~{ISGTA;{IZmNQ2+eUe~v8tI*<9(*P#Pl z9dd=q-WvK(KYyRX@m{81yzm`9>sR0C3FrHo<|(8wT~>a4qe^S3XDxC*6Vw69?RaW% z1meC^>|hG6;!#)?eVf2lPqmJF-zdfQ2H+A6>8Zt3&!| zS;`Q<>9X=O2hO?gP@(@O!3Sl=FKc9Q$1)4K_FFN2r6Tm7wl{-s04eW&d1HKf4!TZi z9@nbXfBMV0el~}@$+RTQEvd)22aQ%R?RCD*Wf%egkJAce9YPdDyqA z`fmkzt{~O@7lgH&7G_}unoD0<2!zXs_1nNJkT~_9est~BQ0TwKv@(^_*5FrJ{G!Y_ zq|n`iGHUVt48vgf4yLZ9c8dCUQM?Yi9P_#`s%;UtlQ4OYS#e#`Vejb!sUs^ zh5p+_P4?{h@Z0g9caB~9>px59sYfoM7WLo!Qut=#f3+4|{o;;2&u=^|;94L0s{UI? zF7@9|ELx%ej-b>5)SOddCSG?(l4B8XEcm@<_1^|+Q2!lA+yYh@7XyjqOdimml@t3D}oc zv6`;_(+Be;a?QpbsQ$Z(@@K(|(0_ZdMVHB+Pi@~`3;pMNvwG`}2e#=P60ez|=76Ki`*A|M@j1VYJuzURz)N=Mz}$#6bP$ca!?+Kdtri zDIdI5|1BbYc>Q-cz0j|xxDQn;y}rN+05xrZAEE!2BIW8o{aH5Bmky(j zChBk=;QKopx$`Sf%eb4#itzzp+F$=24W0+kla7Jo>c2xu`Fj~T&&0~F{yUBScm|ND z|4u_EZG{d;0QDiHssE0kHMwynxnG4mssApb#6dtZftW*)IKOXlbVdJNfJ`0=-;YMt zX0VodA~l>y?d~9T5t4ct_3fg@Q)}qIE2+P#|BitI>c7jeiF+^u(Wr$Tlp3II(82I=Z-Fh>iF+I?%Yu+^xu~%s}1ji_e1Nyr-*-o6^v^+ z7y8fL=I`Ww=x{6a`V83pXS{gTe>bo)^HXT|7JNDG;|;UpN&7YY5B>KNba|5c&mvFg zzi%h~_XBc$rl0=1HR->{dE@B4VEZ*{D)ir@(DU!me?Nd1Px6*Z#yf03Dy5%K)1}Bw zGZbG1cjf}YrlkM;p1^n{sg;Qoz&t)84nUPl)0MYjTt7y55bMgPr# z;`;n-fSdEk*@a&ATQmDXd-b33q50ysFD3nIOBYn~tpB~=7*hY)ua-l#6R3MDFslC! z0&?}=k9zvB`fp1b|Lp^v-0e*Lw;}1jlav1QnbS?ZJ;2sUOO9QRfhM8$Eg4ApjW*=n+<$d52OG7ihSR}=Scnc&7}YC zgXWJV{r7Crf3KsTsQ(`1?Jwo{mZbl_4XxjcH2i?~sGj4!uh4(r=M72q-#zfSogJ#w ze`<)cXyuFSS#<=*tmG+m5&H@K)n5JgP$~VshqO1a57JlY6OXed`e{o27(Mb54@33e zkFtk(8!zc4+M zqW&Hps{a<|zvJDpe?|YDf`9+cw6eJYm}cfL^2S)6zmc7tR)g)$P`9f8R!@0|QL`>(+Izu-+R{;tc9 zBLDbY{roQ#{k#KYuE=MzGu$}dsJV-t>^^iy=JNM|{7Agdux;c8e;4Ij@T41?otWRq zy8rq4525P`&{h8a8T>s5Dz47|De-rC{&DL0O*SS!BEOt=7qRD@{5?M}qaWn01XqG$ zgdJB!{P5?7R3?5cU)YO>FI7#oWRwcqaU*xyMP5m8loPgouj&ihBV$EQE2{Qm*Mfpt z_0`~7w(x52ZsfW-UDsFEQB*)(tUrZ4TYF8tL5yQfSF2sTffH1%w}v8L_yGt{{q)m* zA1hw2iCKg8FlkU<&~E1{tXyyvJm_CP{+88Jrfn+Tvy}o`&gu)UU28>;HM+3&yM|ML zkb{=<%>iY=v6^;;`hxG9y0)#|U7KIPQ9u4lykj`+;&MVvTvvQ0LGHQoG!p*14l$lK zZB_m|*Y+!-^@doDb8jB4p6;saF7)-|ucg4Zi%0R?(+}JgpONt29f165V_*Icw_Z08 zFYUUnL}-Hy{%f@u==C_TRP}x)<$MRj^*L=ST1(@7<7%Gau6)kYmuycFuqVC3UkM>kh~XSm)lo^h6|MUBh_3jVtqQg2wv9KVy%P4Isq zwM=6kv!LGMj8wG;x#PPlEDPbLKC$)p|0@6ICVNxP=yE0Vyn4e-=3w%FDNt;A1^nNK zxm*{v9{KN#RQ?~F=6Cf%P|erG3~@Gd6nDF>H)vT|%8Jko#(eJe)6L9b|5wQW_4J~( z^#3D9!2fd?)oo4uKbro3DkJ=9%y|cTt(If6hH=z1#>K(^GvL2=v-u%;N3;1^+)X0{(x4x$YD2|0-rmH!#Qk0^Ixzzx9SSjPd3FJ*oen z!3^&J-XgD`|6i)`|Le@8{CA{Yow>yP zB`8oLezhZXbOsU#hac#ws%PaE~CB3tB z5odZ)TTwdBQLE{-gEO9D=4D&nM+;Sd#Aqk-1w3)x7y2mc49L;}S3nzeIzy_~ZSFs8 z5Ek)>KkIjW$++;ji}j|!Ew1$#F}HaOe4I-eH)*CD>WX{N(r|QS#Ia(~_r#K6}-VD*MlnIYa%R0Lh zW?>OZxg0e1Uf*l~Y|r?5gEMA5u$;rjOja+o0#9R|3pmF%U*r+m0+Ir=DBLT4eR%7i-^cz2QbL@S zD1Gdtma=7xb7!gPoLLKiZHm9P0I4K2!NZVUEhGVxum!)J^?E06^1=1pdV@Q7S;}=V zeddJ7)|LE#Lyj0LY(g%N!UI?jLub7qrFsq9wsBF1Gtp}Qm44Pz|Lj(ZbRJ?wkKERh1~aE{Suf6tNeAJUFoK0qjYX0Mo2=x=uIUJjWdTf0&A-uKK-hsic+Mv zQ}j`N4#ZQ>DSM|Y{sE5=Yf%v=JsOo*rOy`Su0dS2s_GFMxN3EXtMI(4zkm4sG*@P< zQ(sQ!!iD}5Vm$&v*O*WLF5!|x;V-8Ci=HWsLjP%pP(HN-xvQLx^1eXmqMINNNdl#&|W+R|Jbm+zD|q+jh-vFEHdAGN4G zU$3-3y#BLQ@26h0(sV+CL%EYWq5qtJj3-Tr8^={u{|R5QL!Ger9Y(!#h1#9Z>RKC(l3Qi;nz0~yskH>|NNps=s&-esrQopSB3tY2rTg~gf_x%{C2ci>h0eR zw91Cw)}jC8rQbmFn@?&?ZJMp=-tRn3<4?@A_0${mJ1q2{`{w!8Gp%*LM?8gleY^E6 z)E`@U^LvfHW#Jbm-OtkfB0)hg~;El%R%_uZ6WWw+koUj4IZOUtLb zPP?9}pSbN$;ok4SssHq+4*e&8`|3a6RkvsM)qlPLJq0X-T7~|bMGNMfOl|ds7VJ86 zfFkst-{G1`%xpLzrK8)s=)bwd%prFx@TmV5CfccUCMBNK z2jNn16xSuxpf|VQEcJ_!>OXhQ_q&pQNnsLHQ^urS8zqz>z4KDA_gwrQWfL{I z!{rjrh5nlXl={o5{}xh1y+Mc;(ZW(>N>4&}$(#r!CeY3dVAa!H{Wq0ZcT4xXlwCl% z5WLiX^PtgUa}mQeuS~J^>%V1Ks0;nK80Z{dg#KHC ztawa;XY-Ipzvk9Nd*ita{inB{oUZCWxiFC$8oIuA$$A{?ngtHhI;5bMQ}a_pdJUui$Sn_xq5h zKWU-=_93ndU!ZBUwG@a)qW^raK#5p{WzMfxs{i&&Fi+urDHQ9W_VGZc^t+GiD%zS0 z?+X350(|s@wx8-(-ATTga8&)b4xV&lZ(T{f8~I%Ue|)2$-mngCZlRW{{#!}gYk_$j z@T&h-QB~+aJ<$Aa%@UwqM%(V9p`3v7A zKCu*Q_#9Rg3jKEon5+NX>u7&yrk{8V9G{Gb&02m7{pWXjWBfNI`JK71s(IHzt^I)D zP_R({?F*F4@WIi`F7)4_wD5=5fBOQ(9M&d!@IgNWY>oupmC#aM=NB~#{dY9f(l@__ zRS5OpPVQ#{TNhU`{@YCMjrFn@&!G*_WDRQ)>OVcSr(|2C)$PITSAR-zubS zCo$^3!zsCh{M&${h0-l}1RaiSsQ)%m=VJVh4&ZMesCWckFQNZ-gH^p@2Q@9C=2Phl zM^RG;5FbiS+o8(QzvT-w)VMZp(!JbN7w))TaJB8Cds29!>$@Bgws;-z{~+cQQIb{dWlG7FJ=@ ze;2Wya2OmpE$KfzbfA;^?_%1j>c5j&`BDF!0%TiQz1dC;=kvE1pRPUBb0RhDf;(II zb+3}`(D*poQvd1QSznkz4=eQFHLPwlQ#SP9R^%u2-%cP1{dYDnAJ4l8UGS-@|1QQ? zO#LS}_Xmp|^!-!8Mg4bK(tlU8ex?4qgw*Zi*;5~I+u5;zGA&td(ns{bw{ zR}MAKpsiK(gz>bo6c|TAEA^kfU?K6#;oJGp{Q~sg2^Iaf8%RR`y_%eb{<{`B)Eh$o zy&VbGC;v3~JQFNu{5S>$9^+n~sm%k*r58MV?L}Z3;fdHzL8akx=#D z$#|jl;#IbUUcL+NoL|v@S0bH`|Lz2XKfM0C4gGfo5cJ^h`L2roy8&9BOj{2^nOC80 z9REECA6CzJUY zM&P@cem@fZ_u8cYUP}7!LHPHHr2ihH_Co(%$m(E!{r3#?c`x$VhIj6B?C^abe{V)6 z9sj+jqW>NsN9eyNp!fCk^d5He`7Cp^h)ZE05<{?fe}2 zPcP(4@nOCmJ@R^5`at@Y$5W&|&finyw2Z#4Yml(psp-nS`tMQj_yRS3jNDK0`*^+G z17E~@=&^cOhyD}m9}Loe*Czd^=VCYVGaiZG2g&=hr2oE-_vtg}zvnCZ?>$NXJphI8 zpntpt+57_dR`uWgBh-J-LXm~Y-Xd`Shl>9D7%+blE%8x$>Eran4bbDmQ0<4T1|N?f zYv{kbpmYQB_|v`m?=SG5{VDqILH21c^xsY3r2e}DEYyFWAc3}L;ST-xclhzD|30`^|GD$l&(VLs0P63f|6W8EUk2kg zF!&H}JgEQfPvgJ;(0?)h`w#t>Ap#~Kia*Bz@n`qSQy=p;uKJ$MRbOxoMN6Cc zJsXUP>o^zJDKX_O;D~b8Q5Ia$DE_RcSb6o@Qm!>e+pa^{w)e3D=yh>$S!W37t<5zI zgHXDuRiV$Lg=Ed4Z>G6n|dZzE}($w0oKEdR45g z3AyW6)?rM*ZSBU2m8)<;wOF&XhO$u5-m@zb+Ayu#7G2|XCCAm8Sbr$!AC^vA3Hq1Q zM~kWTxhfi~9@0bpS=v-c4P4O@F7XkQu->|UAT0wU zEmw|z%i#~2+P?6JL3}ehq{5mUONC!{!0PIv_IB4#qaxr9RVl-5&Y73!3TDS+7 zmU+(}&LxE1)lpaGJY3ZXN|lf2q`ck<)+(&xBQLbRD^bdeU#1RPX(iTn?0TF0P#(m` z@+|S0fl%QE5|9%Ujn-q7*DhsZ7#lBmv*trH+$iHn^ zUVE;)^Nghm<=@q>MrNfU|E{Lgl7FGnPUgC$yX$nMd8&ID8>6?sdsHd^z6a~KyxikM z$*L{??h!DZnkG`0wh_Opto%ek>eFN0H^gK8xrb}{GJ)1+Qn&Z6*p-DTz~lZp^Qf~EOJB(UOt=ud zbng?_F{F??@%TNk*}&kts;)RH|GrgRe+c=X4P=X`MQhh6#`f+BGM3rG4C+??mDs6J z(bd!8<=>qS{C3A&O3Y_QEeDq+`FB^4h0MQ4F-!8@g1++aO6elXxHi^B`LZCEv!RAx zuTuWCGPE&oai1plhFL;;e#3Vrc(}7l=>NIk(?M*={{l*sg_)_;Y)TgLFPt-I(LE|w zz}>OTcioX?8CAHak*gmwm~pkyrgWNDQ~sA>>zNNMtHF0IrTo@%PK(-)Tfjy6--p(; z$}VIs8S=j@$;A@d98UkckI80go=DBg{{rq7(9S02=aZ;Q`Cm;B^{2}5C`QMC1 zF64h5c0=WVQ$_yQ^^yNAN&d^<$LNO2A^$t!=X_@W`vBER#BBm9<=-7vPNb!f{{x{+ zGqB5>MOY5B8N1R_7JQ3ee8*Aef!KpW{!gdGM64Ui|7NU&6RD|?|Bdi=H^*k$KbV$U zfWY_lhYq_d@_!oVP1uzV1x|MX(xN*HtBPwK=VND^hwXMfxP|=hO7g!OOm>jszFK9W z0jSSS^6%Rnr()qKg zLjJEuUN2Abzq=y;S0?#?9k!x(! z_U%^w&!g5gSc;YZvy=Sa0#5aZv%$6%sNa_4|2+7&4$Ej0HoZ+)h+aegUWddK`u`nC z{@+qs{Y8{H4Z4g%0^gG4|4!up8RG87_N)9q1)ZPnC;z^2GYNawo3JZAhE?%y%9n+{ z^8XO>d@Yu(i&)8dBX)=9sO7ELq+Ue+pHA|BYtlXIvCFL|{zKGVOa5P?rbY1VG|ro_ zhV_^KuVWJ)%X`qz?UjGOl(hV|6Sg3 zd7M4zpW(gq&(gvnq^{#F^+$Nu{x64>|8MS<|8Mf`M&CnBX=^K=)Ap@Z zD~?b*j}Z#n4cnJ9-`XLpUs`DNM-TePe%tyK*ACh>v^VHK8TKn@h0YO;sU4JZM+mki z@2n}#+IMOPEeF~Hg8%xH>mMoq^&hSsg8%w<3%6rits+`EoX6E0gjN3g6=?adJtXF? zwQA6^6#m5VWgz`M<-b0?^|T-S_j{jO9`tD~`0vQNb_o7Ys_Vt6U%drI%m1 znU+dwxrr}<>MvU#|J`{z`0tlQ^^tWhF^$-I_}5C#;J^N}^53`k<^RlKW=&PP$ba9u zcNYSE==96fyUn-h%STn!@^KaXcfLFw3dn!$3kwHk8{&Rm;=eOjy$CxfHwFsIf5(Ki zLkF{XJ^7Y17T5o}o4e@$iy7b64zr`(0e|0ECTM4@_!X&HzxkiqNa6emNSK! zRsH;5lB8`7qt4*J=Y4^xc3717za-fQ{FZmY|3&bBeeL3m8TGq71gdYT@c$sjWAhoO z9n4&z-mnh(uV98Tj+zcgR*$V*?X08tF>q-$^P6pb_}J)O?nF!+Bg zJkTTNDgA~??9;G-g33V;YjI)75;Cg&s>Zb#vUYp7bEZOwF;A- zqiIh>R(3!E`F|2{H>GoZ{C7Vr{cz8N_S^dK|3dhGbsg>N?R7Tm{3o$Wujkb~W<>7m zb{OOS`uTq|Bl#7K=g-Br=MJvUf`;!J5&!RJ{uKTHLi|WZ!v7m9{C^2=sPpLm^8W(( z|4HT+wZm=n{zv!n|0|SvGjp9+*UkSI*=6lQ=41AM_YJt1S$pC~_Qiau$l=*q^&9taBwQ`;m^|iF@!oB$s8!P)b^E+^ z9436ek=Pf0>x?m$YoG5u}Bqi@z)Bk#m%|RQ24t(=i1oN_`7oH+JU1I*XR1yANad|mc`$7BHyg)TYn=Z zrZSQkOWM2&{^RzRrlK@T?2Er|!xXjqjRxm3^DFqfcX|i)RMXu--Yp9BW}@x_S=Se1Q4#BohggZOX2qSnb6U@9pG zp!xgOU*NAjdLGYZ_i*31x3mzB=P1Yj5b)i|GbQ-HJ3-qQ|D6^54}}Zc$aNUBII2(m zf&YFy-&Xl|AGIvD)@f}d*ZkIwEzD%{spBx$8`}yL|vgMsg)_}2rXJ)J@Hi0 zCKYz6;@4+QJt6Ef=8V?EuIBZ?=h)D-IlB+2)zV(6e|=8H6L08J)!49WxHc{Z;e};s z?}VVBYPCfFE1wlUm$XTRSB9-?*@93O=jl z?eM|pcGb7XnYBAF=)V-!vfBLfU4Qwnl}(Ci?{g0VEj5PW`$2g4_{`S(Nb0*org%GM zs2$Ah$V6*e0l6Mi?u6hMwQ2=DcHH?O`j7m#Ro4rxqc;70e|!SZD7{~tEBYq67BVe$ z{?-bPS@hDfO`mjfP&<=v#5V$4t>AdaxBtxRE|oro+^;~cOs0-nL2n#=h?E;43I6N9 z(4Fe4#Xr9`=R0che;OFb|4CpV|D{B&^1=V9)S~x|{P$fjM^Jk8)DG?y;Jd!F`E{>M zCD-p@_)Vw!_`k5if7_h;3i-bjjF-~#qQw6N>8d{dJK~zp^HcsWhmy0P;xceq0``s6 zSu6PMooS4zZu)tMGpl*BcmDuB=rYXg6SoasT%d6W2EqBma-%yn>@v2>u@f7GoI!?nwMU z4O~u1{6Do;ai~<~{{`@W7vsd>|4EEF%l$%%iZ|emF_8Z!GvceC|F28@-@?dn8s*MP z{6B{NFaM9Enc?++!T&eH|2MMoe-0SP|FgjC`U1#d&g1YHI0GxqMHT)Z4?gE058Ja| z_ma*9BE~cL0!!-89 zoX@)bYCHyl|8L;S53gkn-v0m6@P$e3&;QFP_st6bKgWAU57#WeffBwqcNI`P041*C z_*&xs1IXenlpmgdck=$x(_s6;UjDzI{{Pj)|Htd#|Ks$y57Gbs6?>Tc{~PRb55WJw z2D9J8!&>408vcJQ&w6j|!;5c0nZDw|hlqM#GX%9BqTFK~->2+faQ-9C?b*MGwC z0j|Hp@d(#{%JD(2U*`O09FKGT1m}-%{sG5H9Ipi~jIO;Zh8H+~#`UWzX`XMY+>48N zn13d9h^zPFG_{g{7iSE>sjfG2O+M@5V z>^;Oy;5eA_@?tx2&@j={_#-(qAjpT0b0DipHqG;T@+!OVU70mc@8KMlv8;TMueMX+ zGr8&vc_Iw-0DtE4Vl9mt8ya(t_Rg-+W4gyWMDG`RU!bjb(B@}2KF{?RIlqlV9Nx)U z*zO_zIbi!J2l$$n;x}=LB~2NZZqn>p&i3_}IbO##d3twqJ;IQ<4Qk>? z06DPB8(Z2shF`_){Vp(kf#c69`WepaIsTXf8P_D$`{DYohX+?+fTpprsi_&5`eg3? zI52;jKDJGPX%5g)&xX3A2cEC{Wj^}r;bl?{!-wQaJrjo zaU1IFaJ_G6XlQC`X=!b399)0)31E8(Smo;-To*jA@Km_7HjaYFSCi+ON`B;Es9=AE zg^dX@jV8l|@6hh|IN)3M`3gP{4skB{DZZvx?gv**^HG(9xOxLJs2-u>)OC|mp$qfaXuxn}P&ymqKN%y zb+!Q8Lr*vaA0oFm0?-`maoWX{TgdB~sAt)ocqo8K{#`Khy) z;jLq)-s?Ch-|ybIN_wiVxG&lhChH%fd|&v4M|@Hn)K}D1;Ip@UA9#c>!D#!mmyRyt z#&8T55=czskybKxuvbOrLDcawY{T*r*P+}QC(e~oufy0jqV;ZX3W^J z-Q7Lo#`cUG&wrNl4;P0DGw9Fij^6{vzjDms-f^n3^9ABh<=D=(`to6}>kZ)4Ghxz{ zX>*1z(EGQf|2=j0P~e|A|CW1o=rrK??_B>+t{sEV=0LwCy@<|8V`Ii6z4JMI2Hr*5 zLay7n9?hY?Mc&eLh_PI{S3iLZt}q!c9idM@N*?k3D#x9~eVwy9HBjBaQhtiBhL46elKV77PkjD#Op(x)l<^Hy>6LGOi}>kmz7U~PVNO$B!Qkk8nvv9CawI706jWa1yV_zlz=ivF3#>GCj$CEC6=MvAj!Do0HucE`!-0W=9(A#P3_#@(e%%MCy$H6#I zI;FANeVnD0<-}Q9UBK~&3KcYcDmJ&E13J4VP93W5Cy2ZU7~aMCUJm6KoD#e{xc)HL z>Sk~+_?Pe}4Rc~V=jH2-9B=0S7S1@ybF2#dz8@@z|+WP{FGj zG1S$sX#4LtobQZ+r;fuv!|@UaxTi6=@_825-{bf$*DrIH9<@WxQ*hXjbjDp|d5k(A z&%M()F5#fhrf2uJINwcr1c*GJ}0f0AQ2*T-{~_sBqk1)i|sS&YTM%^5jJ zx{iKm=s%Jjf@qN~etAyyKFp=G0nGfy9Y)zi*93ti@xNhiYN7+2FBY4Nqef&p>3L8 z@Y)Y}14N~zb-inPb;qBUjoEu%(3}2J93On+jvU4@f*zA3s~?y?ml%R5q7IH5(ulao zv4~PG=GXPtoBLN3t(>hFRoK?fATJq_(ul61l6qwCQOrd)@wcP*0Jz0R+IqM49u6h! z87UMMrt=Ck^|apU@MI2uOVjV1-etYB5;rUPp;a-UXK@zZ@tF-~5ql5g5=Sffoi3!_ zlMj3bLrX)`=#JLThSrwR?TwAy ztz8|hP2+mHCXOC8rgKb3YkN=o*q+g2CQO+;W%7iv6MH(x^-P(#e8sBOYuBycu+PSQ zH*MbkfGr1Yt27YxGNl~dnKw2!wvOuVYHjas8b5w)Pur;Rqb5z9Fs@_bgo*POE?T@~ z=`x>U{ewh9U3TV8O&v6D`L?z$02tjfVaklza|aEXkn7IQ?(PW_CQh8>=(i>B=x}U4 zc5F}2`0>+cRjMafw>DArV2z-**0zBLbnfMxtF^tYwXLI_asR0HQJtMU{YQ6ojTtj~ zba(fd?w+w@$Br9EYZJzepD>aCNt5}XGR0;RIvowoElpirvoXUiSyiL)C?RXK^z!GU zqp_nUZ)&3>HMe#)^V8An{G+vFR9AC*b7x1_s8&RE)aagxQyf^%nY(c5vgIpQu3oct z-N4ooJfPRmmbd0D?ai&t9WCu`qehMDY#r6w<&37Q9V{kIo;q#5Dn&q`L2GMkJDIu| zy$-4oS~VhWOp7{4;VP(NPef~NW41I3QvLGW7(#|(AL47Q>dGQCw6%KKkhi5%L)XEBhzlv3?q;D@w*#ldmPxwFWr*ASuU(sTRgJkZ;(kfQy$U!9lV(Ld)!+(sQ&K3PT{9}P4=#UAhDdqCtg@6hZW^4DYTrqGs=dJf#&i4U zJdoR{{pL58rQC8~S<0=?4NghzeuendZsqO0rnmj5f6h;E8|~iy-^x<%90N!DP{J~) z_W8u8+AHs7HN9(7|D5BwjoR-$t}Nv}uPIA;@Yb@F_kW-)Uhbd$32r0h%fBv5`DzPFxDV=CPro5)u;2W$ zl>HAZOF7`=vXld_EKAvPds)iX50#}H^!c)sZGTyoa`11Cp3uPujCF z{Z<}f&98cW|NO^r%Rd9#Gu~B}a^}-zDQA7HEamLKDN8x$_hl*PPVDT5e-*a#R+pum ze?(cz1?QEeTzErS%0=%fOS$-?Whs|@t1RW!zbH$&G{Y*>htpL|Uo*8VWzYJul*@LO zrCfedS;`eRm8D$yKv~LFpD0VY`nzQ**Zit1<+V+tOK9-AnPn;0?pu~}-R`oK*I!ze z@`ksRrCk4TS;`w+CL}!P^&>rQE)?Eai?<%Tn&Vx-8`#cMeWTI`qTD zhxSarz6_$KeCKET=f8*BNV(?+Whw9ar?QlHcVaQ=qYJ9F-Mg?X<-V`CNQl5FX zEalm6l%+iPv$B+r{_nDsk4+w5LW7U5ElYX+sIrt#Tu_$sLT_2hC+{yydGX_ADKGuW z|3lb$z&lZ8e>^i$Kt;t47L1C3sPO2Zs1a0(h=|y*5Tpo-fDcea*Nwd^_O7wJ>MHuT ztu>al>tb2^YE)G0=(_guzcc4|lXrh-4(7A#Bj59#Gq=sjOP!Tt59TUUXUhsd(+6 z|F1huYUtDJTajn_S&?T)Tao7uwj$4;U`1ZI(u%xzpB4Gn%T{F37gpq@R_hpJ@N&V5 zyt0)Qd3CH6`S%Pf^4cj@-|7>eT z-rd`Zyw_|+YG+uH_iwNwA5^W#hi_St#ot+xk5+NN3CbLUkGootPX=3&CHq;CPY<^u zpDnN=pWkdnzIeileEF^w`RYe2^7ZQO7nPY~uyhM6^36_GSu*oMY~y{*3on; z)FwLF3at=bV}(|X9Q4w$XpB(8|#&8yKUpO0=03S~c3i3bl*ITcOpW`BrH4 z=mIOWMzqihtrR;UoI>fVHqIT{;9-K@~Y(T-MVlc;2cIz>lWp-rO;tx)Ia z4lC3pdfp0kjXtqLn?-TK=yJDc11q$7G{6dN5$$e;wv1+2q3+SCI+T{&>l~L2Yx>{h zQz_hS`JU1J;Q?p4yAtXZ{o4xlj+R=XKG8}W1q0DY*f;8Ih5AL?TcQ5ZepYBebc7We z7@cc{wu=64g|?2KwnBrV53SHP(eGAh+o;3F#%OF8^|3<5Xjdz=eRQxD8XTQyg@!~G zE3`xOfEC&?dd&*$6n$fbhDL2SF}ge~>SBe4M}w`w^^Z4 z(KA+P*J!a78Xf&%g?5Y9?PQF`n5eH6+C3U=g~mpQSfM?lldRC5(bZOHujoN5w0HEn z71}5I)(VY_R^HU;^1e}5E3{uU#0u>n9bknHh>o;EJfP$|0I3QdTfwL%9*A6X&y z)}+p=%W2tN&+)Y2wh7Aal&EKT!1C^{l-+}(kydDGbdVLA79D4W4vwy{LWe~6S)u9C zD^}>x=qoEUBU+(LFc6J?&5Sx(p;^&(R_L&3oE2)0=31fI(E=+pC%VN7&5fS4LWf81 zTcIPOU#-x*Xq~RcXdD^!vO@EtU98Yi(NrsRbacEG`b%`B6*?yRhZXv3^r{sqM_*f^ zW1|%}GrD|Sw5b(3J}O$F6QX^s(23FER_LVY94mBkbgLCQC3?yVof>^$g-(lpvqGmw z?YkMHaYoeJ3Y{5^vO;G?)2z_h(Fs;)L3EWBIw!i{3Y{DM+X|f*Eww`DM=Nb^boqj) zvlY59+TIFX6zyk)E{=}Sp|tFt>v&plS4jWsYwKmvP2mAYySq|$FOMF#LRUoZTA?eW zpRCYT(VANX1JO8FCF)^?u8u}np=+YaR_NNOY=y3iF0(?{NB3Bv8={x2(2da-R_Lav z^_E7L{}yd*g>H_vu|l^*dt0GfquEyI@6lOS=(gx@R_ONV2`jWPdd~{o5&dk1?u^#z zZj8qNMNL-du4rc~baynx3f&VOYlZHOF1JGWMfX~ve?%`^q5GpRty^Ro>u6o zXrvW-Iy%S-Jrf;gg`SPButLv8_gSImqgSlZ3(;3Pl$PBUdZO&Eo|fI@qZ-|9`9;x& zF3{rjp#Qq#CG=9Xl@)q9+QSOH63wzguSTa^p?^m=SfSUVN3GE7(K}Y?jpzp}^k%er zFQdzEMO#{-x1(WJ=$&Yy75Yzfj1_t}y2J{-7u{urYSF)}(EHJ6R_KFh`QApCKa2`i zXmPZ)75XUJ(+YhY9cG0-iO#S>OQIXC(5KO3R_L?nKUV1T=tnE`MYKjAV>G^ux?7>I zqTyEP>u8b{S{nV;3Vjn@YK6Xy?zTezjTTv<@1oDG(Ep-VeT^=EA8llXeuxHHp&z5Y ztk6$UvlaR|I@1dM65V8levKZtLcc}tTA|;gpRCXy(VG2?(a6O;tWXq>utIS>S%=cH zTXsAxxbo)($>$s=Ww%v)VR*p7?yiJd$9GtvHu3XTXodI_E3{%9_YZp8IM+(?23DwT zJirRA9Pe(0R*7d=p;hBktx&u8IxDnV{D>7=J$}mytr7pv3auHp8(@saTJh#qXzh3> zE3{5L!3wpHkG4V`;)|@%y78S>XubFaE3|&R#0qT?=LZ^H?ihEpLL0^dtxzEzYlSw7 zXIi0+~?O_)#k~Abv-O(z5%5Ypl?S_#rE_bNq%C8X5oB3hffFvaK;1qvFl1(5~?gR%moQ-U{s&&$mKj z;tQDL%>yO^z?LLQ~>9tk6O6 z^HykT{D~Es7RTEgT|PM8zzQ7_53oYh3`+>FmlV!h))O)*xTKe zvO6=r$_mYj@3%sS#s9WK&GAwzG&^2ta4-;!X3U8@TcNpe@^K<9ULk25b$Gm=6*?k5 z!V1lc&$U8F#(%d$^W&$j&{6S+R_N&XcPsRlxWf>mU&q9Ktk7TMU9C_#KG+H!8=q)} zj*BZ+==k^nD|ABqniV=R{>BQO6t~^M=<>;N7b|p1JlG1I8t-p~PK)PRq0{5@tk4

a_!%p7R=n5>ogM#Sg%-r??r4n0IdNYrbZ$J_3Y`}pVuj9+PqIQ6#8+FP3*!f^ z&_(gFcHeP#ZFc6K4T+gYL8<8fAKVLaCg-4QRaLU+cu zSfT%mpR_`E#qV38yW?N2&^_@w!;R6nH|}MH?u&P^LjQ=TTA};nr@!?kJiTE5V^w0QKEA(Xilofg^ z{=f=79sg#9o{8JdXUac?X1Ts+DOJs(fALNCN8SfLl=tE|w!;`^=8qWIrd=%sk6 z6?!>dX{6ERSK`iA=+$_8EA(2tUl=;8;0x^Q@ex+&jrd$E^k)2bEA&?Uv=w?g{?H1& z6aQ|7{u6iDB^ZrH}P=!f`qEA(UhtrhwyUU{_9<)7oO zR_K>_h!y%ZKEMk779VMaevi+$LVv`!TcKS3St}IfKe9sZ<4$)ox}49iXN8u__p?IF z=XbM0t@6{YQ0x53R;W$>8XZdawGTO-?rY_(V*U>!R?NQ=9&n?(+cxKJ%deFG$_lm3 zuP`PUh{jPX=Q~-URr1?ep;hzatWdlBTr0F%et{KQJ%5W8S|k6Y6R zJHO8E#%QdQ?`4JB=XbF}9r9DH(7O5KtT zw?cjM`&prW`6H}Q|NOaDXh8n&R%l@UX)Cl<{zEIYb^doNG$`L;FEtwJCrtKnJT1Ha zBN3&x4$hAV59sLbN@$1tWGl2&zN|y(X)bd-J&pg=Fv&GMe@A%0iOJn3U3Gsx`+yPo z55fcPN$x)C4*1O3RI)cqxBbc)-l$ZgPfuvJaS$e?B~*;_k|LOw4~0hLT(onv{>nxx9^@Cr732+Q9L& zMd4onP0jZX4``j-P1-do`+#ZrN#Owl++8{OA^E?Cp(K}trsppWL&;HTyY6=XNZS>@ zMSfQPx$uCilDkQ}KF&Viu>7y#0gK#SIr;4TI{UhV8-tSMlF*!duP~Gxm9}da$J2I& z?;)L+pBNs{Ke?N<>zM2Vj?AAQ9x&D2m6IQpzdZ~kxg>OS{@F0pIO>@EM`5UO)L--N zt8rU)G&w5m&3cZfy$Ro%b$q^Oc);?>-J~}ovky2Se_(h(zvOPR?*HNskP7GDg>Z8I zyzqd7lDo+nZp%L4l>8In0T(BClQX;*9?%*?bz1&^;Q`Micat-;+aH~lCiw$S&v$l# z7R%vhe}?VD1N>y1ncpisVDsc|a)##Y1J25y5+1N$ayRM2wf=zcmxkx${}CQ=W^y+< z!>ic`oSXkFJmBHvZgPg@4?w5o46QIq=jYdRffk+q+Ml6c_5l~X!VHFjTMd`4YMmK8w69-@yf1%>I|j@yQtU$v)ur{D|;?j_$6E z!5#U@VJOKZp*!>CFw{8euKZnI1o!9P57h_UT{-sy z`Cr3O^0D_4dMLlngrN70qaM!p3PX*fs`*{QP~)ga^Hal6a#Y&lzc`+@cx9aXpZW7b z^-y{oUmS)SM?IJSBMdc;dOpAIfx!^eKMKFE<7tb- z4e-nPox=k*ba$n3ujZ$Op=1v#q1W=qhM{EhD4{p09TKFDtph8hp7ALX|VL&;;CG~?s^K4B<%P?FFm`8i=I zsl*aml0Q2PH45CP`J2N~qhFup{~3mo%VFi5yS3WH4Rmgm^q-wBaX%UtbS_#g+H{pQ zR?4rk-YTm_tG8~qj{DAwPPvs<+SVcWjUD)B8~4HZt2#P-4fjB?b}qllRx53t-f7i2 zm$25|qwP8f?b2cR8cC*N`wItmh+NElrHA+9_U_zKG<=POuegyrw8u*BBa-?ALR;Kj ze)t-Rzj7nGU57y(Tt8ZZ#K>*o{vRj3lkf3J|CRiwTm4_*KVEQmXzxgHVF?V)zk7+X|PM|9GD*S)*@ zUk~};*j;xWxqB{m=!9uAy1R+U<>nkYYx3;wQ*$o&>^YO%H=nqFyJpU49=XHlA(JLg zoH=Q7^Y}@VrzB3^^YPQ?CZ4-LXWF5Y#~(U*LK0ps$+v>^(fupGQk3u8W>9|R#rwp` zw~No7Gog9T_LC+x51ui)dFI5ybEk|SJhbQdF#`sUA2Moa@7%;`%@cQ@I&I3F6p!oK zzu&TWAH(l!@O}pGZ}0&I9~kgntNLS;ldFml5l? zj9556u1`ICHR<_k@Nm8wJe;ov59h1F!}Gc^>(wXYybT_nx52~nHh6g623P9@=e61s zt`nE1=YV8*RGOXx)3p#Tkwh1+nh&m;53ZUIZk<;(AHK2FdMAA_mQxxtmQxxtmQxxV zkefcextIGtN<&g7e0gw%DZ6s?!l83r+3MME{G8x&a!V$?Fv1aZwAX-iCM+I~i1T~P z!VY;dL+QE;2ezSy6WZYFv`8OLXu}UD)bX@LC~6cG^fhcuvZ!SY)Jc1#*+bo(Q?P2f zU?YicVw!t^t|{&@peJTh)i4*6S?-^CoL>RD0v+1*~UygzJ63bfWbEm^mGA zYccZ?Eydv|ChI80;V9N|IEr-~uDUwbYc$Or_Q=_N(knnWyuY!GWT~6J$`3z-XRNQJ z^-U?)LnB;|jc`3U!u99~*TW-Rw^NEQbvU^YGKzH_tLCSRnvx{F#RE1y_zPA^1nVJ4 zljsphu^xaF>;9)$bzj;&kV>-KcFe?%rf1k3Hv$=ZI8Xa#*Y9*=Bo8N<^}QbN_b11P zy>e&m-8Xxdz{3%4_^MCv)fi_MkVc-cJ#N0?hr{grtc^<@t5%Aw8Y$aPRj~!DB!Z13 zVMkp{#Mb?hrqIH6{s5y;Vyi@zH5r+#dgBuHPu2zHce-qw!@kyW*w;D^`|7aNK9xkU zN+Q@u5)N2Bx4QZyi5f@2;j&2DZHywg@-sKyE)Tfs61eIUxat(R>J_-^7Px9>#zpB` znNropl&Th{RJAXqs&y$!y=LBW1Enenuo>+7a|z2YhAVD}VtaN{Xz zy8jAtxwgwzKn;rEa8%rxv-T4%iR>~}5@Q2y>`4Wy!4<4#SXvTJaWXX4Ce8=KBV5~M zOX>#G95i}f@6OUMdwU~T4VvI^E!C5R{jFoQ&LxQ&2En>hJ=3)wCQmvmT&0nU9_p?w zf>m1t8%b1Kddb6!UariLU`a^g32EF9W4!eqi?V2Ei(cU?Yi|GO^W^306}kIGi%qoy?t8 zgZIhJoiTgbK{F;#DomU@p*a}yhNYT@tg3C`s&U|9>)awvN6*dZl<6}k%n45Jg0goo zUS>#MMe9x5UAzL3zQC3p%B-7GYr{Ue(+kdc@>}2LX1}T;PjIteIq^?^TRx9SuI2Pm zK(zob?ARkf<*c459RCDoEYms;muVe`%e0QeRwir2+AR0-vul>)0ct^HJ^xBhoeofV zt=6$_e`<&APZ~NPyViq;X&SzjM-PPL*B6EGa8eri!!dBYXV2`{B2uhcDYj~)VAV#! zs)>SC3k8P_bi>};PpoqSyy^|*KIYH(vq;7&X&5Ok_dK1QGR)|805b-%!NWml@Ng6o-YebOh7D?Pokx5tPdE~dJZj0}ylR}m>$@Z#I`?o= z-=n#gj_SYht6$ZB7Vq;X$A>+0Q|zCFB)<+Apnn@6#UbpsI|@$#G*630*zJa{I4&bS z|Je)14Y&`er7C;(aH8Fr1&8xo$7(RdR=pA&w%)Zxw$|Y(>o`1R9fzl^Np&wI+jO-76nY6{?+?Hn`PIB`aXsp zFz|AiUIjQH?6hlu-vWp44sd~9)^F#mU(Z>;pA)Wnj{IsJWIs_)TAKYtK(Lwy!QnKx zar4>rIHcJ#p8BNEyE68L^%kifpvH#_Cb=S{2!%~;aMjk#$BKrpuPmd;A&=@Zo};<7 zlC`tLD^lhou6qKMdEsSlWs+9Q%Y_-g>USe7PcHSU_0Mm!8i-@UZn+c5F=}-DbK;g4 zOx+%6Kl=NpbuF&WaC?yo%h*1oar@U&GS2p|o%}DW!*?vWJx==TF?m&B852RJ!>wA` z&xfnCj>E-S$Kl$nV|7tyJsER$=DTJZT%8oYIxDVT)pl^5$M_8teARsL`Uag|x=uEe z?u8rKyl2Gv(knMDCMjbY(jA}bO4gIgWV|z;R3-zMT@wZC;Ye*gswjOeuZ((bUESox zTkBe-htK4~#{uDm>P{fPIHg2MU-7E3Ina7Ag$`4xM#zn4AH}2N!_|B2aM|0!PqGl#-l3G*QFRG?g%}Gktz@${oNlL?E zaV<`%Y8l>rkZr3KljaE9<}-(_a5U@bbRCCdQOD|pl0==+Zz9hGE0Z&TRXo9Qp1Xm*p z9*(J7lbKH;8a&M3;9>p-xALp?RDWtgYZ6?osh(+#&=YCB>qdTuu6=ph>v-n#*Tz$C z_iWz1$EUy#(yphOORB+*mE#^CGN05Z%R0Tl!x61xHK2HbDqIlm^x$g3z{B(n-^#Bh z40&`3kVgwOVe$)*KOg9(T=E+OHwJUE-VBlsO&|XpGx#lsJp1J3BRf?42sIAa)2eX* zSK|P##sM7bCfMcSi5s_GKW&peQP@Pc5(I}WtYg=Z~sp0bX^Q`WJXCrM(oBwVd7iM*!mR;&4jB(<%_ zAz`Xyz;HR6Got5R4hh@pGRc({j#?duqgKay)G{88lTk}?n52%4Bzox6Bzovm9CoLk zI~*^EjTa>ZtK5QBZow)yeuWXvT{2ewh1ATQnEalh@#&J)7$xUv3Q?cx2qc8Bx_ba)CneSI>aJ9PNhqKr4 z)jY{IS1miiYQ+c+PwJMP;P9MvtX7QJMoYpGO)h}6RAgK)!b9J6R5o8>hw4~$D1AkZ zlGp99Lv^fLp8aZ=YrAAuO~m_#!kXiBpGO@~e?t*JPFsJFoId|m?M!Ky+@00q4}VR#?wH_;)KJ4XHv=d z%P(Hta>%@T$*Lj3ndBVwPU z2Ff2HQ>Fi?-qpwCmz|lh_$kek4;w#p*nFM_*&$|}HGM&sUgmK9l3@tD z>l%sQS*Z1Hyh1IwZ`StCcx1*KkTUjzcyP8Ns;Tn&-$3)+;gls)nN_!v6)Zy(Ru<=H z?TL~!criTm8+kHYgg2~abPn%XwIZ2gn;z3ItLJH?zZn@|M#33Sx+#T4Us%HRg(X~H zSi;rx$QVxpCZp>@9BnIJMw#zOWr` zdeYLOry<>j=}9ww#gh4so@DOD*VCExDKm*LTsKF!l}E1&@xwuA!UgjJ5k4~6IpMbtJ~^=6kGQ!ZAsWOmqg|yTts!Oa*I76H*?mk z@$N-`w=JEdwmRu_wk+;hFDDxh_W1j}%m-;}nbcq0rpFC=PNvq6;Be^O`VkxseI19x zQ^#tIaS78}PKHyiNw+@m0vY{*Us`&Dk#r}ize5Edoz=2`E@%4GC+wc5VedQ*JLhTG zH&4~f%geFqbb{6SvR>15sk2_wtz+YqYLF#KxRBjwrNa?6#L=u*{Jb3Yye@~sv$)Tjtn9Tlv)Bsd%ZH*4vGr&q_7!_G9g%8oo%{&0vJc~n1+U{FF` zi_%Z^P@PSw>T60>S5vBbno`x#l&XfOlwUe%eAt+N@g+SVY_wYwDGeL#Y1n8_!$y0W z-8?<4>FM0#)v}(M$!f8_GXYwqC?)^Rw7b*!2yNmN?}hmCbfu$foq%>1CN zhOf>FU!4{_Jg=Knypo|;kq?BE=#D^%4O`ma;qWwg*wO|MTiW1iq2au$2jHrm@(Pt| zreM`d!S3DT)@OQJf5TM&wLkqDJbgmP1yNp1QC$|SdMsFVSg`6Zeo-_qmm4}{$X11} zdmK1-#+pPzOKe?qJV7vV)?M{k^tlVm{69i}eH~9qH<#ONrkrm7*pFx{(%O{^Rn{ms_ z2hOTUKDWGLNt>b;yc3L#!JBYD`Jmq9Hpu-y@rR}N+^5>&=icDS&*bL$9QW_UpPJGJ zUjROjc>1xv&QIdWZC&}1OFpzb$+HmmJ+FZ;BK|Y@XW*^yb8R=2NuH&|dx3vXd=&Vv z#195<<9;T$^y8V`&lAAg6TcF?EAjili{Ks8Z0-vHz)QrJf|rT6b)PPr^s7R=D|nUo z4&XK7C2)KqbI#AtG2mtQGr1Mg|K@U+gIB=)b#Xs<6+Brt$?a`$zjWIP&ixAB4oiAP z@D1Gkq+bQ_{lK>dFN1dl-v@jlczf_8z-!>$!7m1HmwrZbI}IE8^RMe@A>z@Z>zn&5!e;;O-OwKOVdl z@k_zm62Aj{b>dHhwc z@r%Gm5x)(5Eb%A7#}R)QyhQwe;8TdVZ7t(4o%kl;&BV6`pGSOm@MDM{0)7JV4S0q4 zSnwM0gMEH?{+9X6K0on`e177$`TWHH>GQjvE%UzvULyWq@Cxx2-2-JZ4mIKh@Z@L9 z{Qbd8#7BWwh))Ku5kDHd;JyK(W&ZQPOT=#muMmF}yhi*DpC1prUF9^nuYG>vt=#d+ zI8=yl0A3^B2fUDe#YSU&?hIZcKGEkVew5Eo{9Kh>eONur-x<6_d|U7e_+40UW4-Ub@+7%=ez4Dv4X@{A@EY+8eg3t=Jh%G% zYlr-CpWl6>OLFu1-}3p1f8+CG!|VOlZr!Bo!F}~g%RC!^7w|;N`+dM`#CHa-tQY1v z(C1%2hx}TfpZNVgf0xjI$>+xf>c?$~&%asd=iGIe zj6;ohd+_$S3;zeM5ef&rke3pTA$|-{SN45BcLh z|A3Ic?el||B%J#Oyy#x{N^Yg}zwWD_T)j)L3*sAq=e82j`@O+S#D{}di6?b79p|mX zJV$_+iJt{tBYqut5icb8_S_F%A^sA0ZkzDDOTbIS{{XKNU)$CFwEf$LdA0;E6W;;6 zMtmH2al0_jVc-?wr-0{*p??*4iTFL>RpKvz7q$=cECw$V{{_58eDyVD9EyX(Jez@6 zh!??gLqdNq@DlME;8o%$f){oO^IQR5CVn?~jrjB6#T~;uAA(ni{|uhnDfCx&kKf69 zC=u@lUL`&lyf8G(GY-5=ycxVk{8aGburN;ryh8jw@Z9jwUj$wvz688VJm>Z$>G~fL z=4lUJCf)>IBR&kgxO14N1YRLN4?H(gd<<*uEbtQX>%gnT?*}jJ66RS1UMBuAc#ZgP z;Kfm4o;BS*EE%5)@y)?=yN3Su;3eXFfmeyo056OV^PC7?CVn}1jrjk87k3NuJPTeS z{yunaOz8grULwAV+jl18P$j-8cwzT2&mizJ@!i2|#1959jt%o13tl09F?eo|(7zqL zMEptcD)Ik-7xoPEdE8b?YSGgLi`2r+ySBg5qOFCZ{StpYpo~aP#7p+bCP@G9}Gz-z?E zfafNM?LQd2K>RrHBJoSXOT_O4FN1fI)8w88uM&S3JU2x|?|%ngB)(z+^?`T+yh^-3 zcLVgB(xKk>tTe&T2P{KT*G`40*6Kj8Bdf7$0J{;AJTJh!oo zLvDJQe;x25@$TSd;yZ#@iSOt09~$PLthVh@S(#fcVYe3yD7tzKHlc z;7f`B54_zGVf$C z3|=FC6?pm7(7zYFa9YU!1zsio33%!B(9dll{mq>b@($n?;yuBOXNLZ8@EY+6;N`PI ze?EBO?2w-aUL}4jcxgfC{}ViSPRQQ{uMqzpym)Ttud*f9Kk+W$l;`{sj#Ao~bmxlRI_4$ckn z%fttPSBZ}W&s`JdpYHP$Kf&iGe!0(2{4SsW+A#m~K0oorK0onaeSYF=_L6bPT^Hux z0=!6k2kL{XO)b1kc?T^8bKW zh<^uOygl?+>LcS&Bfc?sd12@e1TWkX^3mW`;s=43?hO57z;pi>@(aK##BT*J-WB?f zgV%_^1zx^8^uGZw+!OLPePtY~#5V*l-5dJ-z;pM7d>8Nv@k!vte}w)~;5Fjsf|u_P z{l9@19tioP;8o&pf|ni){cpf?4~2Y%eliXf;v0b%9}fM2;5FjAftMc%{b}HZYRHcT zuM)omy!2@3-vOR`EacCCSBSq4UVJ?Ce*&)&U#-84L-~o&-weF)PvPU_M{Yas6W;^8 zM*I-);*(*XW5FxLF9Od!75aY%FA;wnyh{8{@WRt!o~7Vr;;jduJ`nE+UVJ9Z(-*u# zd?a}8+0dT|ULrmpyh{8W@WOLpo}0kS#2*2#5q}N5_OYjQuqe&D&+LVpx^iTD)oD)D2$3$KTHE(9+VzYV-b{7LZQ8SOZ;`{mh#Ao~b{|WP-23{n7HF%l$ec)B%{{qjw z8|MEQyh!{v@G|i=x5fAn-yA&mUYLI{c#-%%;AP^oz^lYh_W5gJ{wsZc;&=P}#Gm*1 ziGS$xzaQrR#pfr!#&$9eW#XHISBVb+&wUW)-xs_{e74U|{B)n6__aR&hhhE)e177u z`255__xXwEi>MEa!~E-k7m4=u2&Z-MyP;6>usgO`Xu z0A42k5_pC9C*W1$zk%0?udzMG=i^*@E69&rH}C@S?ZJ!0_XaN!p9x+jeiC?v_!Zz) z;&*}9h(8CO`y_1t2jB(bKYFA;wayiELi@CxyjhsZcoiFX385#Jg-_i5PvG2jK_)4+?w%ityA7lW6H zF9fd;e;T|>yarw){v&wqv#|Z`cEI&ZyeoK-coDord~fhF@mb&%;-`RDiC4gD#P0*o zeIB-d5qN?467VAN+>TiP;9VtMZXNIn@$TR?;yZ#DzK{ey&wf5X@!38<@zZ>M;#d3p zUxxYb^ZAJ{^7)A`@%f1-e@~L^qY7Vz`P+k+h&O>(hz|p=5l{XuCC&eJn17znPke#T zPy8mIpLp{3EouIxVg5IKe&S1ge&TJ0N}d|=p-RCEMozMTjF#kh7Kk?Ume&S#I{KVS~NBh4I^KS%RBEA)Ph4}8^HR98K{vX2p zC;I%vuk`te-|O=eUj*LfN6Ft-e&m*dw=;NJvZ0k48T4PN?1Koj_4?}MKKzTD2z{^G9!HUTeym%+z^Cx73Stj`+w zTHyPE=YA7V1V7s62X6;{F?fmm`@k#YzY1OjcgrumeFxs|ce%ehc)OA47r6JEz!#7| z61)oD6?qN?Ujn`&_-Wv|KLmLH7Vxg%-hUdr2;PMG{S>_HMm4#)yXmdfE*NKU?{@(& z#G$_fcp2RLlfkR`&_B-SSx&egpKHKpf&1}%7`y^rl*4lGg4dQ8;Me)j;Kf$L%jnm- zqoiL|@B(;0@EW*ZCwqb~1z!$+GkC7GT#D@y*hXy=vS1@I#H!{8-wKW=Y< zm&yMbyh{GsZsOAGn*4s?g_Wc|KK~f-BDlMo-e!X@0QdE60eF@CJHXqumHgg+5xfZQ z?xwe|!55IEfah`ES>R=GKmMnISHS(_&UN6qRi*t+ z$n!9G5!_!#Z-CDNZwLQd@G|)7;B9x8{$333>t`46D!8wcgTdRillJ&L`+*n1{rWi^ zyaMj)!vgR{l;>vfrQp8(Pk`rElk@st6se zWQKgVqx&APo@S(%|4iDK>%g5tpxA4zmR_onyMoWT>K^v1uJs(FJ*^<@|ZZTUekJ7Pa9T$#Bi=06lDQD11 z9mDzR>#9Z8#=IHPWgm;ys$=ErN|%wmE?D{Nf^~}e7w{#EL^S|WnK~o7>{BSr(lkfdeX|lc(Af2T2OB+pURVFSD%uf7AHm1TA^shH)gnYXM9gk z(i?oyBUQ+(uMbM>>=UMiMKvSi+a;0|>8vT)`f~X6;#aoy?MvCG%=+dl*OKhiQk?V| zvzwjurED&>6epELt{;VE0V*uTNnt5Y3QKWP*!YqhS(C~(zM?^{9A#&ILq;;iawRBV zij%@poD`Pgq%ew;=EmS=e!HM+B#M*DgRkLHT#A#zQk)dd{BFeLtj09;GKLt%N#{2f z9*UFlQJfS5 zs1zrSvvbJKN!iwSz-6B@>-+cIK&Qn?rIzBPuv~8%XD5;3q-?o<6qe$oaMpKxx@Jpp zQnsvmg_rqNUCQ=f6hjYHa^)x+#YuBxu%tLCU5b;!Qk)buljgE>QXIueaTF)TQJfS{i;-qo*`J^~0J1s1VrjJq_7kxg;AU| zHwG8QN%<&Fnj0e~#YyQ>oD@cJQXD%c&5a>OaZ)~tljc&K6i0DV9K}g-6eq>g;-tQ4 zEG-s_ro~Cov^Xi67AHleIBA@HJ}FMhP78~oX{At9ij&6KIixr#TZ)s$*{77^r0le= zC@RHCVY%Kk&Q2o5N!fD!C@jTEVJS`uOL0Jq%ew;;wVm<8$*oZqhaZ)rbPKru#(m4BkQk;~X78XU*N};F}CyldnNO4lO z6eo?dPbtMo*=b!-REm?ra=mGsokWV0vgP_wSc;RvQk)c);-s(?CxzuwQ&@_V!cv?R zmMceL6erD%!II*nbSX{>OL0;d#YuBxa8aC;kK&}cF=A4jlrF_dVH79DQJge4h8V?3 z`6y1BOL0;h#Yu4#C&f{m6iiZq-a{46qVwnarXJ7I4L_VEQ+R; zLQyGB8fWK_;-qXTP8w&QQi_wZ)4HOl6eoq{deb;Ni4-Sg%k`tM6eoqHI4LZ}Nnt5Y z3d^OYuoNeSr8p@pSB}CcPMRBoCB;eUQk)c);-oN&ljg?YqBtoZ#YuBx#H2VWU5b;! zC{Bu_IB9MSF^ZG&QJgfF;-ol=lj0~&ilaCwo)#zl9o}iR&^Rqm8mIM1veF!-D*C3mJzT<9FY3uGXNseqDUN!kI4(%VQO^`dJyRT4m*T#j>3}tIsAuW`)HB6V z&lLCdOb4v7_Vr91;p>?WSi^^UrVc;2dokI^-LY%>zNLqo~eMZXDZ<9 znF{!N76y9Z4GZCWtQ<`%i=ye3uV`B16iu&gMbpBkXnIL1npQ(ar7UTjzD-Nxv|MYP z-9LGcmA12cC|9($vwI^~m9nKeYMedPS#K^)<}mw|Qb|>AxsEl?o-w(Qlr5L4#@Q{A zVySGYWeQ6P)i`@hr0^+Qs*lFm4V24Y*(j2l%cG9w#w_Cs*S;}~s5;v3pFK&LZ@Eks zMpJfoQM^=sythkpW2W%N2j!zaX>Ke8R43)9S8w>7}b^I*N*>#Yxe0 z1Qkt-lcG|bG|qSrsq2RJSwc4^v|U5w%=PMTZm%b0EKd2}Axh$)WZq`9#WP@I&XuGH{7R=zkX znl4C1)8eFPI@^k-#Yxe0!6=#*Cq<<=X`B`(jkCKa?|avFb_b<6X*;`%Qk;}6%U0v; z2Fl{mcJ?WyI4N6-lg8Pnl;WgpS*{vq50w-rWy_k>IJ-M?Whz^WlfqJ*6qe$ov9Z>& zTY}=GvYJSwij(%GI4O?eq`9@ejM+wU(s`sfDURZ#xv>yXoRpug z)bKr4zBnnGE=Wbw;-qLg+lr>eNzrt{D4G^0MWr}toE9gIv%4q7N!!^Sl;WiA>@G@i zQnoBxjk6mli$~kpraE{ij(HX zLO^j+e!5b_w=wwQq-eSz6-|qiqUmfanieNT(*>hwTAUP>;-qm}oHWkvo)jl-XLnGF zleV+FD8)(HvTQZZZlEk4ZD*fSij%UXIBA@HN-0jtmgTB(_E1T2Qnsu~jkCKWSEjP1 zI4LZ}Nnt5Y8XIdZyCo=2DhrB}=Ef|eIB8#sljg<{pg3t?ij(3fPMTZm%b0BxC!I%% zlj0~&ni~rN#Yy?;N~PcX`Rb%`x+FDD>yyUmjBA`$D2>x)qj6fJG?pTj!P6?0!Htee zoyzcyu1clK@Quz&tOmiDD$WpLxXQnR!#%Q%A@<0fTG`?6d! zxX~}UY_%_?OLM7RnoIG@;MOuU+JpL~6QO`*1gxn?3ClP_YFI|V8Vyvjj3cCs=>Y0j zM!;No))GJ|%Sa`)Ob1ZRG6L4}Ksj?qwD?Gv(akd_4xT$D`4Fe%V}ayj7OZ%$KZy@W z3s3Jq$=@e;;Ed5TXAho{aqd2Ua%|sa9NYI#j_tRMWBdKdvHh2EY=84u8L#YPeasqb zzZta0YQUeIcR*&F<-GQ>a^8WN$NHGnX33p>tdCj8N^Z9}?G7(v(=n%% zjl)#?ec#++E;cLK0}P)rB-jU}AM<2I`k2S`H6#7ZNPjajz>EwuBW~ST&345-Ba}XQ z$Q*?T|;z03?JzH67etH=U*o`e9f7f-)|*c@7D`{qU2+K>-;P5O^J`d z2N3rJPktJF^y5$dXYi+y|H)Vh%q4#*{Nu^L3;x;U<7+K)SCC&rp1+a*EBI67FU2~4g?xN$ zeeQkoABO)W`Ry?uzmR`4)=z6!(~_GX|E};i1^4rHJU)WDC;3JA+mU}?JIT8<`6c-K zkUw;7@h6jChCiG9ah=8gEBO`pXOh1y{7cBM!oQLH$Gb@W|0BN!|0VJ#Z6f}E$j@Qi ze%Ri_NJw}bxz`8T1izDa%o{tx7z20xD?TOS|ztAYFRX}g`Ya|7}h!rz*Fw*yXZ zL&>kfpG^Kb@DC%u9ol_1`N{XECb!GT?+X86@?RVx{;gO?x@M7y0kNFOomApZFum{{a3t@&}> z{5kCJEcwgie+B<6@{dFNFD3sw_&1UN39iSx$p0DsW8{z8McVTs`F_*)4*9cCAC{2c z3fJ5B$$uN`{z~$j;NMFA>|v7sKJxp)f0F!1Mv4D2`Gers z$X^ci=L_-&!}r&>pRbwNAGTUS&g18I82mNCz5ixWyaM^7;CCngJFKUz$R7)T82Q6d z&&QHK4*r4U_r??M8RVDXA5H!|_@|IR1^$KPzli<$HRMl+zmWVTcz*F9`OWa3C4Y77 ze_kVh9{k1R7i9QzOUXY5{_o`9fcmgvGJ)>q=l2Bo?ZN&04#U2y6ZxmX??wKr*gtPe z{sQfnBUYw!!? zpN##|7UUO_gzmN#`J*-yz7zQ+_+!a`9{Ee;SK!Ye|2*WMPks&lDdgwy{P%qF3%DMx zA^&si$8ICP1ph(uufu-qY4R)ZUnAc?Kly~J7FX8@o4ZJ@58TmE%Ka&4E+P@s) zetrw9$$3`?_wzdp>!Bn0CHPyAzoEP4liL9DEAV$B|7GmQ#*klw@5jlvXCv&#rjuX5 zI-gJZU&nszB=Sq}Zzg{OtlN9YufTtT{I7dRe;1Ko!Z^Q6{_mTM{~7s(HHH63e#goqlk9|dc1=rE9?C&h?Y=iYxZ$Ey2x;D5U&xL6J#^e|9xZgznT7xA2Ao6SQ{qH}0 z{`si4dy-$l>(c)BpWeR``=wdrm+-i747F!6_DiRcUnodBFDCy(*pIzIehGE^WAbBM@86PN*hKQ@aNYa%Jb-a-3-0H)27g`hSHSa* z&g54*N&Y_MUyc1(k^Iu8;*TQ#%TdC|kzeR6d@A|9b`?H{{2Kh@$iD*ntFy?jbdfxl zlfSem{3h~CxQ^~2zZ3RjkC9)%ye}gENbIBDA-@LyGx8^3fAu~2m2T3`Mrd$ ziTu}4AI>Gefa{_{{ygl*ZY944|9s-LO{~G&>XUQ*MU-1?B zy|Ewrnfx03Hpu7aYk91bHNpLS74bN-G5KraI_ge-1^yuN`{05ZMt*K9%oq9X@c4cp z`6c+X$iEf)qNB;L!at4t9vFuU$uDdz?YWNp?N$)Jko+?IhspmZ>c+F=*WkZF{>{5d z{>9`Mu@Cu{{OQR5JNXs(Z808xe(&lh`P+m0`OR%3yfgX7;&G%G`6c*8_Ay^0$*;m6 zNB&dTk4+)JfPKXr^0z?0%H)^fpGE!x)Z0tRufe~G{56NmINU{kaXaCUk-xN?@E6Ii zz<-DQpK)C*AwO4?Jl~W5C?02HjFX?Q68v`Hetx^7U+a@!h2M?*4tN~tM}A>@Y0nPi zzl{CZX!6VO4$A0WS@^eEZ z|C8jOK0x@(+3-d-z{@�Q1_;gzhYnUo5?T1FO&Z*+J6T5Rrr^Z zKM(t{8^|w=kn`R}{;ql9Rr1U5UnD=qKJYE_Yw-Q=&;9uChW*%g!&3jAK=566CNTk`!I-ba$Z9`<8V`q?G@Q<71 zcSgT%B)<&*Zt@?;_&i2_4gMnXcN!r5`VaXrQ?N{vh%nT~6{3C%+1RFY=$meryu?1^uB? zmEf-l?&r7N=8|V4@~iNBkiXhi;twLfu)FXPiiTr=zapYa{OMah2{^y%W{-4ON z!f)MC;(osTb+jh9?{8sG@ir#^8q|j#}h-FTsC;{0Fh$c!~Tf{P)N|75lL-$S>?8 z?fIGfX6(mWSfIYw(-MZ-u(O4f(}!l4xi0Z$drXoBRs=Ddaa{ zd}foM+gI`*Oa4skXU-zO1pjjKpT~aeZ{%0u-%EZMT&GWvU)WFD^D_Ax_Z9vg`DOTD zlE31b;{Qy34St(~#Ql6Nz~ksz;C_CK`-`^;`3GS?)cH;yI03jccY$74TsC;5f(x%5^g-~G*JdV2x9K0ff@CclXN*b?$f z@V_U&gvaIlM!EFn^OxbT2JYwUp>4$LNPY$W7UaK$@fk>d75-52_a7kn$C6)ze<1mX zt|0zQ@^dBOe?2Hf06tTupfJy{4)Gc z$-k*3$NrD}GWeuwBbl!n{MEtz{N_4}w;}nt1BGu%{wVCn zwj#d(e;D~6V?VYB`9=5>$&Wk9d1sMdf`1J8N8owN>ExH;Uqb#rP#uAK`0C((ehcsm@#N>G$oL#e{^8h<%_qMI{}l3H!G7!l^2_kACI1_Y&qDI6@E<0B z4(jc5ScNg#FkU@{90G!FT?+Y{K><`|Bn1B{21fm=WAQ+$5sXR*H`Xf$+H3Z z+hIS}jr=0~0pzzr`*$S24B!8~#ft89$@|-9V?XBKujJcPg+GJxAAtSXQItP-h_wGy z^4GzB>_YO3@UJ6(a%;(R2l-|AkC6Y{F!7%!zY6~?@;h`A{}b|a(}n+!{Ijqhi#L6v}zX*Q``PX1S_CNB= z@bldypYQKNxtnVT?&r4(za#nmM#%x2lb@R@d?5L6#KLzXzX*RU`3GQpCXio-Ka>0` zupc{`{3`s@$p01lv5Uyh&60LrPySxmkKIXr5q_2YG1!m2KzesgKBpRe3ua(^}O72VyWzFp-0pWHfD7ODE}U~{~GzT;4dbBt=%O5 zH{>sX{|EVtQUBX+A;w^3FT?)S|`5ji4(Z64VU~!lD`1{$>g7p>+5{-7s9`W{8zAlxSjk(@E;<7 zH0txSR0@>F28n{wm;pevd|f*CT&4{LRR3*I)AY zBYzhB9mpTiMf}~!UjTnR`4{Xi{&eye!kp6_2n{!;i0$-jRk z$^Q`f?T!%s9QiBb`M?|GH^Kjy{P%lFp8t|R8h+FyaX()(+R6P@!2SHrg1zd!j))|dP{kiQWA81g^C{qf{4f`2IapKT}k=aat_{wd^Nj{V66D6z$zLAN6Fw$?7W@@^Nwx?Ds=(ir{L5Al zzZdz%BZU{qpN{?0F67tX?@Rs`yGfp@}}s1GaRy7co^JVx@j2lw;q zKR;_z@@w#WlmG8sB~Ow3@?V9IBLCc?@O{ZIl!g1>xBK=Shke-L0frB+ohI zmyQ*F75P0^7Je)Fx#NW2PySx*gg-@o1^&Ouf1{iDACO->Uieb-KTA69ZoiRVgTE5? zJAQnA+g|+k;C_C~CkXFMezcMB-sBff6uv$ATO-zjTu1IfDFN zs|!DY{M^aH&n15>uHUQ3ufYF1`KOGLJpOZo{P+}45&ks!6Y==|Z^~bT{~`I;U_Z8$ z{PL-i|9A4AXf1rDKJwGIr*N9w?*Q)Sw{1aqXY#A?`;hKJeU09nUcRk{*eB{|4x1l{sZLu*VCUSzkHVDd5!$r zb{GC3`GvEEe?$KK5yF2bzY4!?Uy1wqnvHtf0o>1TX@PiM$p0Msu|DMI&Jlkw`HvQb z?@E3J{{G~T-$Q)=`RKkq#dC$vBmZR7w-YIU4gPuLPZ}k8D&&{X6Mh@{(FVdFAir?F z@Mp+xkH@pu$gjd*O#b>s$@2~Qr3-}rLH_-CzSFj!#Qpf>E|mN0g8TVhdu`!e$gjZf zOMV-?-Z+^2;zg2YH2EE|AKRb&8vJ9)KYbO+a~ApKi-liK{{BtE|3-cl{=MY)#q+Tz z$j@COd0r-eIv%gzBfkj$OY&pX=byQ(Q@9k!2Ntx;cr6zD6G#W@^hC; zo^8p05&PAh$uGj+hx~IpOP(p@m*LMLf2B>uKbHI|{IkiQhI)QE`MJv^&&}j_*-7}l z^J^Neii;JB0kgpVWtzCpqdBEJZKF8M>z{^Q6m!(TxD zJE(70kY9y=3;FAAAnm!2{9NV#JG=AvDyqAW;{zlJ*h&IemlBvzK@AW=tAs^6BD+OV z76lh>5~5TgVb?0l^znI=O&_S1O{*8#gj(65T9*OQE-YbDE1Qlhn>z@&RC_1C?@{=? z_^bEz(z)}!@A=J{bLP&RBqZ1JSK*(iYxxfNK>i*04!-$M;6wRu;on#N+U;z+ANpVZ zEah%|m+1O@9=tc#w!auYPxCAHb9+}mknag!@GGk`0QE!p!SGv?f|dw>O2m=v7_aGf)C`Mg}*}A+gIU3`Pbm@mwyL7lK&KbvF1PD!h7?qopsu4nOP)1 z?;Fy{*3VL&bXRf-3*?)^Uz~6LV)#%#fFIw~d{6jD{wDZWy+~3a!5e?=7%8$KmH{K9;TP&=37DUthUddXAIVREe?jxHsi>cN%IeR7 z&(-P%mnvdnfNAefJXZNr=9pFBlug@{;%L8`O|bi zcgK5J^RWiXUHemOt$q{u)_Im+1n>RD^2_1f-~H?XpO(K7zPE36%HV@%EguR0jpkz^ zd@TPE{5oBqAB7K}v-*qSFV%c(4ZQzX^BdqhYJD4gB>y)2{-nb*kB{I}&s+XA{A8`4 z7TD`R0{;El=G($Y@?GJhX6F0A`+v8*1io!k%PZhR z`El?!X}&QTK9-*a@9TcI06zGK?RO=7TJy08J}tim{wdAJcEfxBwE73&_iH|O6h0-N zb(L-B#;ZW{v0UYDd?WeB@H^B$E#Uo)R<|Aej7u%=3Lnb%g@3u~U;kY5?cihiZt!;%n(qrAR9apNKU(b{2A`H6 z4_~LH)tLhCZMA$hd^gR<7Q(0GSHZun^Jg7=Bwq=Chj07c1MhFM{2;vh`{~EvL;38^ zww)WVH+6lkr`(NiEbqhj)O@TZe6Zc>wuc{}`BFFdw0u8!ue#MKh4*$?J{zpLQ=*DPNTzec_iK9t`Jzq7T~IS3!iABTTT^RaC0$BkF; zy49(#+>LLE-tRtqTD}nenWk2!J-qjZ<=x?r%DZ{1Yfnmk5d3WgR%bZsNAeTkYh|0C z3h)2R@;UI6lLOB@7Qu(|tKpx}d~7{@EdL?=<}n@B06VR+gWk-1Sc= z-w?h?$9o}sB;N*pndW1i;Jux;-|OK!>HR(sK9C;@f1sDuxd%R!p9uf(HRk^SAIZ;y zucP_QGI(#7)p-$qctguK!Uys@;d|-){185rKLY>s`BuMLH!U-ZWJn_Uy2{=7_Eh^D z!h5@I`vUm2x-PeY59B+;_t*UDdiYR21^>PLQ20pxUid3DADam8?XmXHfUh{$@_F!q z{Brm|UuynE_)vZm{4SmUJK-bweemx0W{<#odu_kfyW7%@*OI{2>neBe$3Q+0{*oT% z3*bZfBKUcinC}c9$@hlOZ(`p4JxJFc?=8#A;s4dZ@_SJ~ke>waYd$suK9rviU!d__ z4j;+C1pn_2)}Br9-rJV%f_I-Aw+}v${}Mi5^Ren02iHHLe2#KAz60}Yzj^SHd~^7t zdcPOJd$HB&0{=VT^4{=4Y`OdQ?{zY($q+v?AU z_ujF51^nn-%U^;I*BkEdlvm5- zRhNKw%{79b*wFIk%AF77+rn?reYy*LDBlPEbIr$!;UoD9_*IRpJ!9d$_bi_be^0*U zGvNdI1@PY&nO^}P%17{LG&8>$K9b)JKfb{Het7SF%a6kQx<1#?eeZ|0c-tX@3%ewvy<+s3puld++)KAMFfM2Zn*iraMK1=rpH(qVza+SOG#PW^d z(|SL)fcHMMerN}OdsEB1!u#@l;UCiXe@fs3`C;&b)c$esDfubzTRK^LX2FN@3*qN! zezg)lEx!(a^95Fa3w$KM2mVIQ#}2^9^2gxs*Zn$6Po>lPP0n69J2bzyn z!u#@j;cIGsbr3#~KMp@mK3msmH(n|E`pVt-KB)Pa47M_IjPnBAKr)(0JEZ?%JQ0&xdc;%(gFtkK{YRPtP*n9X^)7 z0e-RkAb9VP)foZ5JvorfV*uhIQtBYaAJCw%G8tUVvXr{#~p zH@(1oHO-q`|Htxml_!Upj934*<{QHMA6Z@i?>^704SY(zGrar!@9W{y^6u}fyY^hK z_sdZDSpHtrcfYUhehNe+K+>%`KmY`YHM4@Kbfaco9A=zX`sV#$zXZEWZyv zon!4e0`Grfd39YcUH>e<*z&r{-SMX6-M`Ou{vYxM@M-xX)c@m^R=+cREZ-Y`tM0!k zc>hzYQx2b3X!*VHDfvn812q4f0iTwi4`0;P>Mw_n5( zpOXI)-fL~XdLLW5@k-0*D0k!atuZeTK9+9|U+Zk!pa|ao-108)U+H}44WE)PhHux+ z>XgH$<;TL`r1#4t_*i}>{3GXE{rT|z7nZMp|GUNBOYkZA&G1WV+6KGe)AIY_m-aCK zC44OJK7YxL*9=`xa{AhKZhZa2w%$m&^E*zryg7VIzAgM3%{RKhr{(*=U#9y}F?=jv z0q;Klbu7Gp#M(I-{(W5^X2PfB7r^iLt9Hb$!?jAItAX{rNiI_QU&M z+J2A1*9a`H(a)A{yi)SH%3XWD>te1Ed|JK*e1l(@ZwnvGcZJU@Fy9B>KWcdiysztF z1$;_=9Q^Cutz)IYh(-T21xm%{gJXWMs#uXWt=Uhwz++VWfA&z8Rv-n8f44S#|BWAJ0t zp2hHi{ATzMbiBLZr^$Z@KST9TztLLe`X`dVNV)6JYMsq>fDgX5+;`$_%~F)5xKdSL<4Ij$)g+EXCmlF6` z{(ktQYX8IV-oLGVYvF6D{s#C!emi`-EUWW2d`kXf_(1i)hEK~k8esKY|NKn%m*&cU zIDh1?g&(T^zZpK~JF9yK{C4&KUGRbY|H0p^_WvG!n*190wtBz33?IqwgD+}g?K}d% zU%vWHC-=`izqIwb%3c3>-&>vsKS%eA0{9E$uYqsf+Unc{AIMLDcb^9^6+ZNmmU-SB z_}ojZ{v!BTel`3SwSPUlU)}0&g?B%v-wPkgAA;|Fj#9C>VFI$)HI)a z%gM*Pw1%xWQl6;n%zu%5NBFO6o4*!5mLCb9eWv*k{xkXc@E12UzZ~8>&D#Gu{8)>< zci|)Xnzvd#*FVG6KlPQnAk^DaRZ93i~@ZL|Y{nd-Dp6h@2efGM_ z6O~*Kefd22G0klI0{E1C5qx8vZ=K;o`QGsE@AReMBl+?0bJagn;A8pO@GEpZUkLA= zQLXC0R>9w|`s?6x&(bwd36g z-(UU>^lkXa8i|0RzGI)81= z^L+P2%j7n}HYG1TqU{cq3Ti>yHj|&K|7NNGmMyjolm1J_i2c_ild)#9#e~t8Zb(*6 zc+e(aelSb;Rbwo5v9Y-TvKjVkSP-_J7@E;zcl<7%n|X4o{+o7+{>#Z&x4rAv+)T#z zUQ+uhZNDs8IpM+fC+lo`!dq=N>8t;f>05Fi;Qo_y>Qwvh)x@ec=#y0Y@xlH72TbYT Ag8%>k literal 0 HcmV?d00001 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h index e5b99246d5..196121799c 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h @@ -31,7 +31,7 @@ #ifndef __NR_LDPC_TYPES__H__ #define __NR_LDPC_TYPES__H__ -#include "PHY/TOOLS/time_meas.h" +#include "../../TOOLS/time_meas.h" #include "nrLDPCdecoder_defs.h" // ============================================================================== // TYPES diff --git a/openair1/PHY/TOOLS/time_meas.h b/openair1/PHY/TOOLS/time_meas.h index 2deab40f27..5b8ea6e75a 100644 --- a/openair1/PHY/TOOLS/time_meas.h +++ b/openair1/PHY/TOOLS/time_meas.h @@ -29,8 +29,8 @@ #include #include #include -#include -#include +//#include +//#include // global var to enable openair performance profiler extern int opp_enabled; double cpu_freq_GHz __attribute__ ((aligned(32)));;