func computeInverse8(input []int, output []int, shift uint) { oIdx := 0 round := (1 << shift) >> 1 for i := 0; i < 8; i++ { x0 := input[i] x1 := input[i+8] x2 := input[i+16] x3 := input[i+24] x4 := input[i+32] x5 := input[i+40] x6 := input[i+48] x7 := input[i+56] a0 := (W8_8 * x1) + (W8_24 * x3) + (W8_40 * x5) + (W8_56 * x7) a1 := (W8_9 * x1) + (W8_25 * x3) + (W8_41 * x5) + (W8_57 * x7) a2 := (W8_10 * x1) + (W8_26 * x3) + (W8_42 * x5) + (W8_58 * x7) a3 := (W8_11 * x1) + (W8_27 * x3) + (W8_43 * x5) + (W8_59 * x7) a4 := (W8_16 * x2) + (W8_48 * x6) a5 := (W8_17 * x2) + (W8_49 * x6) a6 := (W8_0 * x0) + (W8_32 * x4) a7 := (W8_1 * x0) + (W8_33 * x4) b0 := a6 + a4 b1 := a7 + a5 b2 := a6 - a4 b3 := a7 - a5 c0 := (b0 + a0 + round) >> shift c1 := (b1 + a1 + round) >> shift c2 := (b3 + a2 + round) >> shift c3 := (b2 + a3 + round) >> shift c4 := (b2 - a3 + round) >> shift c5 := (b3 - a2 + round) >> shift c6 := (b1 - a1 + round) >> shift c7 := (b0 - a0 + round) >> shift output[oIdx] = kanzi.Clamp(c0, MIN_VAL8, MAX_VAL8) output[oIdx+1] = kanzi.Clamp(c1, MIN_VAL8, MAX_VAL8) output[oIdx+2] = kanzi.Clamp(c2, MIN_VAL8, MAX_VAL8) output[oIdx+3] = kanzi.Clamp(c3, MIN_VAL8, MAX_VAL8) output[oIdx+4] = kanzi.Clamp(c4, MIN_VAL8, MAX_VAL8) output[oIdx+5] = kanzi.Clamp(c5, MIN_VAL8, MAX_VAL8) output[oIdx+6] = kanzi.Clamp(c6, MIN_VAL8, MAX_VAL8) output[oIdx+7] = kanzi.Clamp(c7, MIN_VAL8, MAX_VAL8) oIdx += 8 } }
func computeInverse4(input, output []int, shift uint) { round := (1 << shift) >> 1 x0 := input[0] x1 := input[1] x2 := input[2] x3 := input[3] x4 := input[4] x5 := input[5] x6 := input[6] x7 := input[7] x8 := input[8] x9 := input[9] x10 := input[10] x11 := input[11] x12 := input[12] x13 := input[13] x14 := input[14] x15 := input[15] a0 := (W4_4 * x4) + (W4_12 * x12) a1 := (W4_5 * x4) + (W4_13 * x12) a2 := (W4_0 * x0) + (W4_8 * x8) a3 := (W4_1 * x0) + (W4_9 * x8) a4 := (W4_4 * x5) + (W4_12 * x13) a5 := (W4_5 * x5) + (W4_13 * x13) a6 := (W4_0 * x1) + (W4_8 * x9) a7 := (W4_1 * x1) + (W4_9 * x9) a8 := (W4_4 * x6) + (W4_12 * x14) a9 := (W4_5 * x6) + (W4_13 * x14) a10 := (W4_0 * x2) + (W4_8 * x10) a11 := (W4_1 * x2) + (W4_9 * x10) a12 := (W4_4 * x7) + (W4_12 * x15) a13 := (W4_5 * x7) + (W4_13 * x15) a14 := (W4_0 * x3) + (W4_8 * x11) a15 := (W4_1 * x3) + (W4_9 * x11) b0 := (a2 + a0 + round) >> shift b1 := (a3 + a1 + round) >> shift b2 := (a3 - a1 + round) >> shift b3 := (a2 - a0 + round) >> shift b4 := (a6 + a4 + round) >> shift b5 := (a7 + a5 + round) >> shift b6 := (a7 - a5 + round) >> shift b7 := (a6 - a4 + round) >> shift b8 := (a10 + a8 + round) >> shift b9 := (a11 + a9 + round) >> shift b10 := (a11 - a9 + round) >> shift b11 := (a10 - a8 + round) >> shift b12 := (a14 + a12 + round) >> shift b13 := (a15 + a13 + round) >> shift b14 := (a15 - a13 + round) >> shift b15 := (a14 - a12 + round) >> shift output[0] = kanzi.Clamp(b0, MIN_VAL4, MAX_VAL4) output[1] = kanzi.Clamp(b1, MIN_VAL4, MAX_VAL4) output[2] = kanzi.Clamp(b2, MIN_VAL4, MAX_VAL4) output[3] = kanzi.Clamp(b3, MIN_VAL4, MAX_VAL4) output[4] = kanzi.Clamp(b4, MIN_VAL4, MAX_VAL4) output[5] = kanzi.Clamp(b5, MIN_VAL4, MAX_VAL4) output[6] = kanzi.Clamp(b6, MIN_VAL4, MAX_VAL4) output[7] = kanzi.Clamp(b7, MIN_VAL4, MAX_VAL4) output[8] = kanzi.Clamp(b8, MIN_VAL4, MAX_VAL4) output[9] = kanzi.Clamp(b9, MIN_VAL4, MAX_VAL4) output[10] = kanzi.Clamp(b10, MIN_VAL4, MAX_VAL4) output[11] = kanzi.Clamp(b11, MIN_VAL4, MAX_VAL4) output[12] = kanzi.Clamp(b12, MIN_VAL4, MAX_VAL4) output[13] = kanzi.Clamp(b13, MIN_VAL4, MAX_VAL4) output[14] = kanzi.Clamp(b14, MIN_VAL4, MAX_VAL4) output[15] = kanzi.Clamp(b15, MIN_VAL4, MAX_VAL4) }
func computeInverse16(input, output []int, shift uint) { oIdx := 0 round := (1 << shift) >> 1 for i := 0; i < 16; i++ { x0 := input[i] x1 := input[i+16] x2 := input[i+32] x3 := input[i+48] x4 := input[i+64] x5 := input[i+80] x6 := input[i+96] x7 := input[i+112] x8 := input[i+128] x9 := input[i+144] x10 := input[i+160] x11 := input[i+176] x12 := input[i+192] x13 := input[i+208] x14 := input[i+224] x15 := input[i+240] a0 := (W16_16 * x1) + (W16_48 * x3) + (W16_80 * x5) + (W16_112 * x7) + (W16_144 * x9) + (W16_176 * x11) + (W16_208 * x13) + (W16_240 * x15) a1 := (W16_17 * x1) + (W16_49 * x3) + (W16_81 * x5) + (W16_113 * x7) + (W16_145 * x9) + (W16_177 * x11) + (W16_209 * x13) + (W16_241 * x15) a2 := (W16_18 * x1) + (W16_50 * x3) + (W16_82 * x5) + (W16_114 * x7) + (W16_146 * x9) + (W16_178 * x11) + (W16_210 * x13) + (W16_242 * x15) a3 := (W16_19 * x1) + (W16_51 * x3) + (W16_83 * x5) + (W16_115 * x7) + (W16_147 * x9) + (W16_179 * x11) + (W16_211 * x13) + (W16_243 * x15) a4 := (W16_20 * x1) + (W16_52 * x3) + (W16_84 * x5) + (W16_116 * x7) + (W16_148 * x9) + (W16_180 * x11) + (W16_212 * x13) + (W16_244 * x15) a5 := (W16_21 * x1) + (W16_53 * x3) + (W16_85 * x5) + (W16_117 * x7) + (W16_149 * x9) + (W16_181 * x11) + (W16_213 * x13) + (W16_245 * x15) a6 := (W16_22 * x1) + (W16_54 * x3) + (W16_86 * x5) + (W16_118 * x7) + (W16_150 * x9) + (W16_182 * x11) + (W16_214 * x13) + (W16_246 * x15) a7 := (W16_23 * x1) + (W16_55 * x3) + (W16_87 * x5) + (W16_119 * x7) + (W16_151 * x9) + (W16_183 * x11) + (W16_215 * x13) + (W16_247 * x15) b0 := (W16_32 * x2) + (W16_96 * x6) + (W16_160 * x10) + (W16_224 * x14) b1 := (W16_33 * x2) + (W16_97 * x6) + (W16_161 * x10) + (W16_225 * x14) b2 := (W16_34 * x2) + (W16_98 * x6) + (W16_162 * x10) + (W16_226 * x14) b3 := (W16_35 * x2) + (W16_99 * x6) + (W16_163 * x10) + (W16_227 * x14) b4 := (W16_0 * x0) + (W16_128 * x8) + (W16_64 * x4) + (W16_192 * x12) b5 := (W16_0 * x0) + (W16_128 * x8) - (W16_64 * x4) - (W16_192 * x12) b6 := (W16_1 * x0) + (W16_129 * x8) + (W16_65 * x4) + (W16_193 * x12) b7 := (W16_1 * x0) + (W16_129 * x8) - (W16_65 * x4) - (W16_193 * x12) c0 := b4 + b0 c1 := b6 + b1 c2 := b7 + b2 c3 := b5 + b3 c4 := b5 - b3 c5 := b7 - b2 c6 := b6 - b1 c7 := b4 - b0 d0 := (c0 + a0 + round) >> shift d1 := (c1 + a1 + round) >> shift d2 := (c2 + a2 + round) >> shift d3 := (c3 + a3 + round) >> shift d4 := (c4 + a4 + round) >> shift d5 := (c5 + a5 + round) >> shift d6 := (c6 + a6 + round) >> shift d7 := (c7 + a7 + round) >> shift d8 := (c7 - a7 + round) >> shift d9 := (c6 - a6 + round) >> shift d10 := (c5 - a5 + round) >> shift d11 := (c4 - a4 + round) >> shift d12 := (c3 - a3 + round) >> shift d13 := (c2 - a2 + round) >> shift d14 := (c1 - a1 + round) >> shift d15 := (c0 - a0 + round) >> shift output[oIdx] = kanzi.Clamp(d0, MIN_VAL16, MAX_VAL16) output[oIdx+1] = kanzi.Clamp(d1, MIN_VAL16, MAX_VAL16) output[oIdx+2] = kanzi.Clamp(d2, MIN_VAL16, MAX_VAL16) output[oIdx+3] = kanzi.Clamp(d3, MIN_VAL16, MAX_VAL16) output[oIdx+4] = kanzi.Clamp(d4, MIN_VAL16, MAX_VAL16) output[oIdx+5] = kanzi.Clamp(d5, MIN_VAL16, MAX_VAL16) output[oIdx+6] = kanzi.Clamp(d6, MIN_VAL16, MAX_VAL16) output[oIdx+7] = kanzi.Clamp(d7, MIN_VAL16, MAX_VAL16) output[oIdx+8] = kanzi.Clamp(d8, MIN_VAL16, MAX_VAL16) output[oIdx+9] = kanzi.Clamp(d9, MIN_VAL16, MAX_VAL16) output[oIdx+10] = kanzi.Clamp(d10, MIN_VAL16, MAX_VAL16) output[oIdx+11] = kanzi.Clamp(d11, MIN_VAL16, MAX_VAL16) output[oIdx+12] = kanzi.Clamp(d12, MIN_VAL16, MAX_VAL16) output[oIdx+13] = kanzi.Clamp(d13, MIN_VAL16, MAX_VAL16) output[oIdx+14] = kanzi.Clamp(d14, MIN_VAL16, MAX_VAL16) output[oIdx+15] = kanzi.Clamp(d15, MIN_VAL16, MAX_VAL16) oIdx += 16 } }
func computeInverse32(input, output []int, shift uint) { oIdx := 0 round := (1 << shift) >> 1 for i := 0; i < 32; i++ { x0 := input[i] x1 := input[i+32] x2 := input[i+64] x3 := input[i+96] x4 := input[i+128] x5 := input[i+160] x6 := input[i+192] x7 := input[i+224] x8 := input[i+256] x9 := input[i+288] x10 := input[i+320] x11 := input[i+352] x12 := input[i+384] x13 := input[i+416] x14 := input[i+448] x15 := input[i+480] x16 := input[i+512] x17 := input[i+544] x18 := input[i+576] x19 := input[i+608] x20 := input[i+640] x21 := input[i+672] x22 := input[i+704] x23 := input[i+736] x24 := input[i+768] x25 := input[i+800] x26 := input[i+832] x27 := input[i+864] x28 := input[i+896] x29 := input[i+928] x30 := input[i+960] x31 := input[i+992] a0 := (w[32] * x1) + (w[96] * x3) + (w[160] * x5) + (w[224] * x7) + (w[288] * x9) + (w[352] * x11) + (w[416] * x13) + (w[480] * x15) + (w[544] * x17) + (w[608] * x19) + (w[672] * x21) + (w[736] * x23) + (w[800] * x25) + (w[864] * x27) + (w[928] * x29) + (w[992] * x31) a1 := (w[33] * x1) + (w[97] * x3) + (w[161] * x5) + (w[225] * x7) + (w[289] * x9) + (w[353] * x11) + (w[417] * x13) + (w[481] * x15) + (w[545] * x17) + (w[609] * x19) + (w[673] * x21) + (w[737] * x23) + (w[801] * x25) + (w[865] * x27) + (w[929] * x29) + (w[993] * x31) a2 := (w[34] * x1) + (w[98] * x3) + (w[162] * x5) + (w[226] * x7) + (w[290] * x9) + (w[354] * x11) + (w[418] * x13) + (w[482] * x15) + (w[546] * x17) + (w[610] * x19) + (w[674] * x21) + (w[738] * x23) + (w[802] * x25) + (w[866] * x27) + (w[930] * x29) + (w[994] * x31) a3 := (w[35] * x1) + (w[99] * x3) + (w[163] * x5) + (w[227] * x7) + (w[291] * x9) + (w[355] * x11) + (w[419] * x13) + (w[483] * x15) + (w[547] * x17) + (w[611] * x19) + (w[675] * x21) + (w[739] * x23) + (w[803] * x25) + (w[867] * x27) + (w[931] * x29) + (w[995] * x31) a4 := (w[36] * x1) + (w[100] * x3) + (w[164] * x5) + (w[228] * x7) + (w[292] * x9) + (w[356] * x11) + (w[420] * x13) + (w[484] * x15) + (w[548] * x17) + (w[612] * x19) + (w[676] * x21) + (w[740] * x23) + (w[804] * x25) + (w[868] * x27) + (w[932] * x29) + (w[996] * x31) a5 := (w[37] * x1) + (w[101] * x3) + (w[165] * x5) + (w[229] * x7) + (w[293] * x9) + (w[357] * x11) + (w[421] * x13) + (w[485] * x15) + (w[549] * x17) + (w[613] * x19) + (w[677] * x21) + (w[741] * x23) + (w[805] * x25) + (w[869] * x27) + (w[933] * x29) + (w[997] * x31) a6 := (w[38] * x1) + (w[102] * x3) + (w[166] * x5) + (w[230] * x7) + (w[294] * x9) + (w[358] * x11) + (w[422] * x13) + (w[486] * x15) + (w[550] * x17) + (w[614] * x19) + (w[678] * x21) + (w[742] * x23) + (w[806] * x25) + (w[870] * x27) + (w[934] * x29) + (w[998] * x31) a7 := (w[39] * x1) + (w[103] * x3) + (w[167] * x5) + (w[231] * x7) + (w[295] * x9) + (w[359] * x11) + (w[423] * x13) + (w[487] * x15) + (w[551] * x17) + (w[615] * x19) + (w[679] * x21) + (w[743] * x23) + (w[807] * x25) + (w[871] * x27) + (w[935] * x29) + (w[999] * x31) a8 := (w[40] * x1) + (w[104] * x3) + (w[168] * x5) + (w[232] * x7) + (w[296] * x9) + (w[360] * x11) + (w[424] * x13) + (w[488] * x15) + (w[552] * x17) + (w[616] * x19) + (w[680] * x21) + (w[744] * x23) + (w[808] * x25) + (w[872] * x27) + (w[936] * x29) + (w[1000] * x31) a9 := (w[41] * x1) + (w[105] * x3) + (w[169] * x5) + (w[233] * x7) + (w[297] * x9) + (w[361] * x11) + (w[425] * x13) + (w[489] * x15) + (w[553] * x17) + (w[617] * x19) + (w[681] * x21) + (w[745] * x23) + (w[809] * x25) + (w[873] * x27) + (w[937] * x29) + (w[1001] * x31) a10 := (w[42] * x1) + (w[106] * x3) + (w[170] * x5) + (w[234] * x7) + (w[298] * x9) + (w[362] * x11) + (w[426] * x13) + (w[490] * x15) + (w[554] * x17) + (w[618] * x19) + (w[682] * x21) + (w[746] * x23) + (w[810] * x25) + (w[874] * x27) + (w[938] * x29) + (w[1002] * x31) a11 := (w[43] * x1) + (w[107] * x3) + (w[171] * x5) + (w[235] * x7) + (w[299] * x9) + (w[363] * x11) + (w[427] * x13) + (w[491] * x15) + (w[555] * x17) + (w[619] * x19) + (w[683] * x21) + (w[747] * x23) + (w[811] * x25) + (w[875] * x27) + (w[939] * x29) + (w[1003] * x31) a12 := (w[44] * x1) + (w[108] * x3) + (w[172] * x5) + (w[236] * x7) + (w[300] * x9) + (w[364] * x11) + (w[428] * x13) + (w[492] * x15) + (w[556] * x17) + (w[620] * x19) + (w[684] * x21) + (w[748] * x23) + (w[812] * x25) + (w[876] * x27) + (w[940] * x29) + (w[1004] * x31) a13 := (w[45] * x1) + (w[109] * x3) + (w[173] * x5) + (w[237] * x7) + (w[301] * x9) + (w[365] * x11) + (w[429] * x13) + (w[493] * x15) + (w[557] * x17) + (w[621] * x19) + (w[685] * x21) + (w[749] * x23) + (w[813] * x25) + (w[877] * x27) + (w[941] * x29) + (w[1005] * x31) a14 := (w[46] * x1) + (w[110] * x3) + (w[174] * x5) + (w[238] * x7) + (w[302] * x9) + (w[366] * x11) + (w[430] * x13) + (w[494] * x15) + (w[558] * x17) + (w[622] * x19) + (w[686] * x21) + (w[750] * x23) + (w[814] * x25) + (w[878] * x27) + (w[942] * x29) + (w[1006] * x31) a15 := (w[47] * x1) + (w[111] * x3) + (w[175] * x5) + (w[239] * x7) + (w[303] * x9) + (w[367] * x11) + (w[431] * x13) + (w[495] * x15) + (w[559] * x17) + (w[623] * x19) + (w[687] * x21) + (w[751] * x23) + (w[815] * x25) + (w[879] * x27) + (w[943] * x29) + (w[1007] * x31) b0 := (w[64] * x2) + (w[192] * x6) + (w[320] * x10) + (w[448] * x14) + (w[576] * x18) + (w[704] * x22) + (w[832] * x26) + (w[960] * x30) b1 := (w[65] * x2) + (w[193] * x6) + (w[321] * x10) + (w[449] * x14) + (w[577] * x18) + (w[705] * x22) + (w[833] * x26) + (w[961] * x30) b2 := (w[66] * x2) + (w[194] * x6) + (w[322] * x10) + (w[450] * x14) + (w[578] * x18) + (w[706] * x22) + (w[834] * x26) + (w[962] * x30) b3 := (w[67] * x2) + (w[195] * x6) + (w[323] * x10) + (w[451] * x14) + (w[579] * x18) + (w[707] * x22) + (w[835] * x26) + (w[963] * x30) b4 := (w[68] * x2) + (w[196] * x6) + (w[324] * x10) + (w[452] * x14) + (w[580] * x18) + (w[708] * x22) + (w[836] * x26) + (w[964] * x30) b5 := (w[69] * x2) + (w[197] * x6) + (w[325] * x10) + (w[453] * x14) + (w[581] * x18) + (w[709] * x22) + (w[837] * x26) + (w[965] * x30) b6 := (w[70] * x2) + (w[198] * x6) + (w[326] * x10) + (w[454] * x14) + (w[582] * x18) + (w[710] * x22) + (w[838] * x26) + (w[966] * x30) b7 := (w[71] * x2) + (w[199] * x6) + (w[327] * x10) + (w[455] * x14) + (w[583] * x18) + (w[711] * x22) + (w[839] * x26) + (w[967] * x30) c0 := (w[128] * x4) + (w[384] * x12) + (w[640] * x20) + (w[896] * x28) c1 := (w[129] * x4) + (w[385] * x12) + (w[641] * x20) + (w[897] * x28) c2 := (w[130] * x4) + (w[386] * x12) + (w[642] * x20) + (w[898] * x28) c3 := (w[131] * x4) + (w[387] * x12) + (w[643] * x20) + (w[899] * x28) c4 := (w[256] * x8) + (w[768] * x24) c5 := (w[257] * x8) + (w[769] * x24) c6 := (w[0] * x0) + (w[512] * x16) c7 := (w[1] * x0) + (w[513] * x16) c8 := c6 + c4 c9 := c7 + c5 c10 := c7 - c5 c11 := c6 - c4 d0 := c8 + c0 d1 := c9 + c1 d2 := c10 + c2 d3 := c11 + c3 d4 := c11 - c3 d5 := c10 - c2 d6 := c9 - c1 d7 := c8 - c0 e0 := d0 + b0 e1 := d1 + b1 e2 := d2 + b2 e3 := d3 + b3 e4 := d4 + b4 e5 := d5 + b5 e6 := d6 + b6 e7 := d7 + b7 e8 := d7 - b7 e9 := d6 - b6 e10 := d5 - b5 e11 := d4 - b4 e12 := d3 - b3 e13 := d2 - b2 e14 := d1 - b1 e15 := d0 - b0 r0 := (e0 + a0 + round) >> shift r1 := (e1 + a1 + round) >> shift r2 := (e2 + a2 + round) >> shift r3 := (e3 + a3 + round) >> shift r4 := (e4 + a4 + round) >> shift r5 := (e5 + a5 + round) >> shift r6 := (e6 + a6 + round) >> shift r7 := (e7 + a7 + round) >> shift r8 := (e8 + a8 + round) >> shift r9 := (e9 + a9 + round) >> shift r10 := (e10 + a10 + round) >> shift r11 := (e11 + a11 + round) >> shift r12 := (e12 + a12 + round) >> shift r13 := (e13 + a13 + round) >> shift r14 := (e14 + a14 + round) >> shift r15 := (e15 + a15 + round) >> shift r16 := (e15 - a15 + round) >> shift r17 := (e14 - a14 + round) >> shift r18 := (e13 - a13 + round) >> shift r19 := (e12 - a12 + round) >> shift r20 := (e11 - a11 + round) >> shift r21 := (e10 - a10 + round) >> shift r22 := (e9 - a9 + round) >> shift r23 := (e8 - a8 + round) >> shift r24 := (e7 - a7 + round) >> shift r25 := (e6 - a6 + round) >> shift r26 := (e5 - a5 + round) >> shift r27 := (e4 - a4 + round) >> shift r28 := (e3 - a3 + round) >> shift r29 := (e2 - a2 + round) >> shift r30 := (e1 - a1 + round) >> shift r31 := (e0 - a0 + round) >> shift output[oIdx] = kanzi.Clamp(r0, MIN_VAL32, MAX_VAL32) output[oIdx+1] = kanzi.Clamp(r1, MIN_VAL32, MAX_VAL32) output[oIdx+2] = kanzi.Clamp(r2, MIN_VAL32, MAX_VAL32) output[oIdx+3] = kanzi.Clamp(r3, MIN_VAL32, MAX_VAL32) output[oIdx+4] = kanzi.Clamp(r4, MIN_VAL32, MAX_VAL32) output[oIdx+5] = kanzi.Clamp(r5, MIN_VAL32, MAX_VAL32) output[oIdx+6] = kanzi.Clamp(r6, MIN_VAL32, MAX_VAL32) output[oIdx+7] = kanzi.Clamp(r7, MIN_VAL32, MAX_VAL32) output[oIdx+8] = kanzi.Clamp(r8, MIN_VAL32, MAX_VAL32) output[oIdx+9] = kanzi.Clamp(r9, MIN_VAL32, MAX_VAL32) output[oIdx+10] = kanzi.Clamp(r10, MIN_VAL32, MAX_VAL32) output[oIdx+11] = kanzi.Clamp(r11, MIN_VAL32, MAX_VAL32) output[oIdx+12] = kanzi.Clamp(r12, MIN_VAL32, MAX_VAL32) output[oIdx+13] = kanzi.Clamp(r13, MIN_VAL32, MAX_VAL32) output[oIdx+14] = kanzi.Clamp(r14, MIN_VAL32, MAX_VAL32) output[oIdx+15] = kanzi.Clamp(r15, MIN_VAL32, MAX_VAL32) output[oIdx+16] = kanzi.Clamp(r16, MIN_VAL32, MAX_VAL32) output[oIdx+17] = kanzi.Clamp(r17, MIN_VAL32, MAX_VAL32) output[oIdx+18] = kanzi.Clamp(r18, MIN_VAL32, MAX_VAL32) output[oIdx+19] = kanzi.Clamp(r19, MIN_VAL32, MAX_VAL32) output[oIdx+20] = kanzi.Clamp(r20, MIN_VAL32, MAX_VAL32) output[oIdx+21] = kanzi.Clamp(r21, MIN_VAL32, MAX_VAL32) output[oIdx+22] = kanzi.Clamp(r22, MIN_VAL32, MAX_VAL32) output[oIdx+23] = kanzi.Clamp(r23, MIN_VAL32, MAX_VAL32) output[oIdx+24] = kanzi.Clamp(r24, MIN_VAL32, MAX_VAL32) output[oIdx+25] = kanzi.Clamp(r25, MIN_VAL32, MAX_VAL32) output[oIdx+26] = kanzi.Clamp(r26, MIN_VAL32, MAX_VAL32) output[oIdx+27] = kanzi.Clamp(r27, MIN_VAL32, MAX_VAL32) output[oIdx+28] = kanzi.Clamp(r28, MIN_VAL32, MAX_VAL32) output[oIdx+29] = kanzi.Clamp(r29, MIN_VAL32, MAX_VAL32) output[oIdx+30] = kanzi.Clamp(r30, MIN_VAL32, MAX_VAL32) output[oIdx+31] = kanzi.Clamp(r31, MIN_VAL32, MAX_VAL32) oIdx += 32 } }