bsrinit(bsr0);

bsrmovf(bsr0, zmm0, zmm0);
bsrmovf(bsr0, zmm8, zmm8);
bsrmovf(bsr0, zmm16, zmm16);
bsrmovf(bsr0, zmm24, zmm24);
bsrmovf(bsr0, zmm0, zmm24);
bsrmovf(bsr0, zmm8, zmm16);
bsrmovf(bsr0, zmm16, zmm8);
bsrmovf(bsr0, zmm24, zmm0);
bsrmovf(bsr0, zmm0, zword [rax+rcx*1+0x10]);
bsrmovf(bsr0, zmm8, zword [r8+r9*2+0x20]);
bsrmovf(bsr0, zmm16, zword [r16+r17*4+0x40]);
bsrmovf(bsr0, zmm24, zword [r24+r25*8+0x7f]);

bsrmovh(bsr0, zmm0);
bsrmovh(bsr0, zmm8);
bsrmovh(bsr0, zmm16);
bsrmovh(bsr0, zmm24);
bsrmovh(zmm0, bsr0);
bsrmovh(zmm8, bsr0);
bsrmovh(zmm16, bsr0);
bsrmovh(zmm24, bsr0);
bsrmovh(bsr0, zword [rax+rcx*1+0x10]);
bsrmovh(bsr0, zword [r8+r9*2+0x20]);
bsrmovh(bsr0, zword [r16+r17*4+0x40]);
bsrmovh(bsr0, zword [r24+r25*8+0x7f]);
bsrmovh(zword [rax+rcx*1+0x10], bsr0);
bsrmovh(zword [r8+r9*2+0x20], bsr0);
bsrmovh(zword [r16+r17*4+0x40], bsr0);
bsrmovh(zword [r24+r25*8+0x7f], bsr0);

bsrmovl(bsr0, zmm0);
bsrmovl(bsr0, zmm8);
bsrmovl(bsr0, zmm16);
bsrmovl(bsr0, zmm24);
bsrmovl(zmm0, bsr0);
bsrmovl(zmm8, bsr0);
bsrmovl(zmm16, bsr0);
bsrmovl(zmm24, bsr0);
bsrmovl(bsr0, zword [rax+rcx*1+0x08]);
bsrmovl(bsr0, zword [r8+r9*2+0x18]);
bsrmovl(bsr0, zword [r16+r17*4+0x28]);
bsrmovl(bsr0, zword [r24+r25*8+0x38]);
bsrmovl(zword [rax+rcx*1+0x08], bsr0);
bsrmovl(zword [r8+r9*2+0x18], bsr0);
bsrmovl(zword [r16+r17*4+0x28], bsr0);
bsrmovl(zword [r24+r25*8+0x38], bsr0);

tilemovcol(tmm1, zmm0, eax);
tilemovcol(tmm2, zmm8, r8d);
tilemovcol(tmm3, zmm16, r16d);
tilemovcol(tmm4, zmm24, r24d);
tilemovcol(tmm1, zmm0, r24d);
tilemovcol(tmm2, zmm8, r16d);
tilemovcol(tmm3, zmm16, r8d);
tilemovcol(tmm4, zmm24, eax);
tilemovcol(tmm1, zmm0, 0x00);
tilemovcol(tmm2, zmm8, 0x12);
tilemovcol(tmm3, zmm16, 0x2D);
tilemovcol(tmm4, zmm24, 0x3F);

tilemovrow(tmm1, zmm0, eax);
tilemovrow(tmm2, zmm8, r8d);
tilemovrow(tmm3, zmm16, r16d);
tilemovrow(tmm4, zmm24, r24d);
tilemovrow(tmm1, zmm0, r24d);
tilemovrow(tmm2, zmm8, r16d);
tilemovrow(tmm3, zmm16, r8d);
tilemovrow(tmm4, zmm24, eax);
tilemovrow(tmm1, zmm0, 0x00);
tilemovrow(tmm2, zmm8, 0x12);
tilemovrow(tmm3, zmm16, 0x2D);
tilemovrow(tmm4, zmm24, 0x3F);

top2bf16ps(tmm1, zmm0, zmm0);
top2bf16ps(tmm2, zmm8, zmm8);
top2bf16ps(tmm3, zmm16, zmm16);
top2bf16ps(tmm4, zmm24, zmm24);
top2bf16ps(tmm1, zmm0, zmm24);
top2bf16ps(tmm2, zmm8, zmm16);
top2bf16ps(tmm3, zmm16, zmm8);
top2bf16ps(tmm4, zmm24, zmm0);

top4bssd(tmm1, zmm0, zmm0);
top4bssd(tmm2, zmm8, zmm8);
top4bssd(tmm3, zmm16, zmm16);
top4bssd(tmm4, zmm24, zmm24);
top4bssd(tmm1, zmm0, zmm24);
top4bssd(tmm2, zmm8, zmm16);
top4bssd(tmm3, zmm16, zmm8);
top4bssd(tmm4, zmm24, zmm0);

top4bsud(tmm1, zmm0, zmm0);
top4bsud(tmm2, zmm8, zmm8);
top4bsud(tmm3, zmm16, zmm16);
top4bsud(tmm4, zmm24, zmm24);
top4bsud(tmm1, zmm0, zmm24);
top4bsud(tmm2, zmm8, zmm16);
top4bsud(tmm3, zmm16, zmm8);
top4bsud(tmm4, zmm24, zmm0);

top4busd(tmm1, zmm0, zmm0);
top4busd(tmm2, zmm8, zmm8);
top4busd(tmm3, zmm16, zmm16);
top4busd(tmm4, zmm24, zmm24);
top4busd(tmm1, zmm0, zmm24);
top4busd(tmm2, zmm8, zmm16);
top4busd(tmm3, zmm16, zmm8);
top4busd(tmm4, zmm24, zmm0);

top4buud(tmm1, zmm0, zmm0);
top4buud(tmm2, zmm8, zmm8);
top4buud(tmm3, zmm16, zmm16);
top4buud(tmm4, zmm24, zmm24);
top4buud(tmm1, zmm0, zmm24);
top4buud(tmm2, zmm8, zmm16);
top4buud(tmm3, zmm16, zmm8);
top4buud(tmm4, zmm24, zmm0);

top4mxbf8ps(tmm1, zmm0, zmm0, 0x00);
top4mxbf8ps(tmm2, zmm8, zmm8, 0x12);
top4mxbf8ps(tmm3, zmm16, zmm16, 0x2D);
top4mxbf8ps(tmm4, zmm24, zmm24, 0x3F);
top4mxbf8ps(tmm1, zmm0, zmm24, 0x3F);
top4mxbf8ps(tmm2, zmm8, zmm16, 0x2D);
top4mxbf8ps(tmm3, zmm16, zmm8, 0x12);
top4mxbf8ps(tmm4, zmm24, zmm0, 0x00);

top4mxbhf8ps(tmm1, zmm0, zmm0, 0x00);
top4mxbhf8ps(tmm2, zmm8, zmm8, 0x12);
top4mxbhf8ps(tmm3, zmm16, zmm16, 0x2D);
top4mxbhf8ps(tmm4, zmm24, zmm24, 0x3F);
top4mxbhf8ps(tmm1, zmm0, zmm24, 0x3F);
top4mxbhf8ps(tmm2, zmm8, zmm16, 0x2D);
top4mxbhf8ps(tmm3, zmm16, zmm8, 0x12);
top4mxbhf8ps(tmm4, zmm24, zmm0, 0x00);

top4mxhbf8ps(tmm1, zmm0, zmm0, 0x00);
top4mxhbf8ps(tmm2, zmm8, zmm8, 0x12);
top4mxhbf8ps(tmm3, zmm16, zmm16, 0x2D);
top4mxhbf8ps(tmm4, zmm24, zmm24, 0x3F);
top4mxhbf8ps(tmm1, zmm0, zmm24, 0x3F);
top4mxhbf8ps(tmm2, zmm8, zmm16, 0x2D);
top4mxhbf8ps(tmm3, zmm16, zmm8, 0x12);
top4mxhbf8ps(tmm4, zmm24, zmm0, 0x00);

top4mxhf8ps(tmm1, zmm0, zmm0, 0x00);
top4mxhf8ps(tmm2, zmm8, zmm8, 0x12);
top4mxhf8ps(tmm3, zmm16, zmm16, 0x2D);
top4mxhf8ps(tmm4, zmm24, zmm24, 0x3F);
top4mxhf8ps(tmm1, zmm0, zmm24, 0x3F);
top4mxhf8ps(tmm2, zmm8, zmm16, 0x2D);
top4mxhf8ps(tmm3, zmm16, zmm8, 0x12);
top4mxhf8ps(tmm4, zmm24, zmm0, 0x00);

top4mxbssps(tmm1, zmm0, zmm0, 0x00);
top4mxbssps(tmm2, zmm8, zmm8, 0x12);
top4mxbssps(tmm3, zmm16, zmm16, 0x2D);
top4mxbssps(tmm4, zmm24, zmm24, 0x3F);
top4mxbssps(tmm1, zmm0, zmm24, 0x3F);
top4mxbssps(tmm2, zmm8, zmm16, 0x2D);
top4mxbssps(tmm3, zmm16, zmm8, 0x12);
top4mxbssps(tmm4, zmm24, zmm0, 0x00);

// vcvtps2bf8: opCvt5 shape, dst always xm, src grows xm/ym/zm
vcvtps2bf8(xm0, xm0);
vcvtps2bf8(xm8, xm8);
vcvtps2bf8(xm16, xm16);
vcvtps2bf8(xm24, xm24);
vcvtps2bf8(xm0, xm24);
vcvtps2bf8(xm8, xm16);
vcvtps2bf8(xm16, xm8);
vcvtps2bf8(xm24, xm0);
vcvtps2bf8(xm0, ym0);
vcvtps2bf8(xm8, ym8);
vcvtps2bf8(xm16, ym16);
vcvtps2bf8(xm24, ym24);
vcvtps2bf8(xm0, ym24);
vcvtps2bf8(xm8, ym16);
vcvtps2bf8(xm16, ym8);
vcvtps2bf8(xm24, ym0);
vcvtps2bf8(xm0, zm0);
vcvtps2bf8(xm8, zm8);
vcvtps2bf8(xm16, zm16);
vcvtps2bf8(xm24, zm24);
vcvtps2bf8(xm0, zm24);
vcvtps2bf8(xm8, zm16);
vcvtps2bf8(xm16, zm8);
vcvtps2bf8(xm24, zm0);
vcvtps2bf8(xm0, xword [rax+rcx*1+0x10]);
vcvtps2bf8(xm8, yword [r8+r9*2+0x20]);
vcvtps2bf8(xm16, zword [r16+r17*4+0x40]);
vcvtps2bf8(xm24, zword [r24+r25*8+0x7f]);
vcvtps2bf8(xm0, xword_b [rax+rcx*1+0x10]);
vcvtps2bf8(xm8, yword_b [r8+r9*2+0x20]);
vcvtps2bf8(xm16, zword_b [r16+r17*4+0x40]);
vcvtps2bf8(xm0|k4|T_z, xword [rax+rcx*1+0x10]);
vcvtps2bf8(xm8|k5, zword_b [r8+r9*2+0x40]);
vcvtps2bf8(xm0|k4, xm8);
vcvtps2bf8(xm8|k5, xm16);
vcvtps2bf8(xm16|k6, xm24);
vcvtps2bf8(xm24|k7|T_z, xm0);
vcvtps2bf8(xm0|k4, ym8);
vcvtps2bf8(xm8|k5, ym16);
vcvtps2bf8(xm16|k6, ym24);
vcvtps2bf8(xm24|k7|T_z, ym0);
vcvtps2bf8(xm0|k4, zm8);
vcvtps2bf8(xm8|k5, zm16);
vcvtps2bf8(xm16|k6, zm24);
vcvtps2bf8(xm24|k7|T_z, zm0);

// vcvtps2bf8s: opCvt5 shape, dst always xm, src grows xm/ym/zm
vcvtps2bf8s(xm0, xm0);
vcvtps2bf8s(xm8, xm8);
vcvtps2bf8s(xm16, xm16);
vcvtps2bf8s(xm24, xm24);
vcvtps2bf8s(xm0, xm24);
vcvtps2bf8s(xm8, xm16);
vcvtps2bf8s(xm16, xm8);
vcvtps2bf8s(xm24, xm0);
vcvtps2bf8s(xm0, ym0);
vcvtps2bf8s(xm8, ym8);
vcvtps2bf8s(xm16, ym16);
vcvtps2bf8s(xm24, ym24);
vcvtps2bf8s(xm0, ym24);
vcvtps2bf8s(xm8, ym16);
vcvtps2bf8s(xm16, ym8);
vcvtps2bf8s(xm24, ym0);
vcvtps2bf8s(xm0, zm0);
vcvtps2bf8s(xm8, zm8);
vcvtps2bf8s(xm16, zm16);
vcvtps2bf8s(xm24, zm24);
vcvtps2bf8s(xm0, zm24);
vcvtps2bf8s(xm8, zm16);
vcvtps2bf8s(xm16, zm8);
vcvtps2bf8s(xm24, zm0);
vcvtps2bf8s(xm0, xword [rax+rcx*1+0x10]);
vcvtps2bf8s(xm8, yword [r8+r9*2+0x20]);
vcvtps2bf8s(xm16, zword [r16+r17*4+0x40]);
vcvtps2bf8s(xm24, zword [r24+r25*8+0x7f]);
vcvtps2bf8s(xm0, xword_b [rax+rcx*1+0x10]);
vcvtps2bf8s(xm8, yword_b [r8+r9*2+0x20]);
vcvtps2bf8s(xm16, zword_b [r16+r17*4+0x40]);
vcvtps2bf8s(xm0|k4|T_z, xword [rax+rcx*1+0x10]);
vcvtps2bf8s(xm8|k5, zword_b [r8+r9*2+0x40]);
vcvtps2bf8s(xm0|k4, xm8);
vcvtps2bf8s(xm8|k5, xm16);
vcvtps2bf8s(xm16|k6, xm24);
vcvtps2bf8s(xm24|k7|T_z, xm0);
vcvtps2bf8s(xm0|k4, ym8);
vcvtps2bf8s(xm8|k5, ym16);
vcvtps2bf8s(xm16|k6, ym24);
vcvtps2bf8s(xm24|k7|T_z, ym0);
vcvtps2bf8s(xm0|k4, zm8);
vcvtps2bf8s(xm8|k5, zm16);
vcvtps2bf8s(xm16|k6, zm24);
vcvtps2bf8s(xm24|k7|T_z, zm0);

// vcvtps2hf8: opCvt5 shape, dst always xm, src grows xm/ym/zm
vcvtps2hf8(xm0, xm0);
vcvtps2hf8(xm8, xm8);
vcvtps2hf8(xm16, xm16);
vcvtps2hf8(xm24, xm24);
vcvtps2hf8(xm0, xm24);
vcvtps2hf8(xm8, xm16);
vcvtps2hf8(xm16, xm8);
vcvtps2hf8(xm24, xm0);
vcvtps2hf8(xm0, ym0);
vcvtps2hf8(xm8, ym8);
vcvtps2hf8(xm16, ym16);
vcvtps2hf8(xm24, ym24);
vcvtps2hf8(xm0, ym24);
vcvtps2hf8(xm8, ym16);
vcvtps2hf8(xm16, ym8);
vcvtps2hf8(xm24, ym0);
vcvtps2hf8(xm0, zm0);
vcvtps2hf8(xm8, zm8);
vcvtps2hf8(xm16, zm16);
vcvtps2hf8(xm24, zm24);
vcvtps2hf8(xm0, zm24);
vcvtps2hf8(xm8, zm16);
vcvtps2hf8(xm16, zm8);
vcvtps2hf8(xm24, zm0);
vcvtps2hf8(xm0, xword [rax+rcx*1+0x10]);
vcvtps2hf8(xm8, yword [r8+r9*2+0x20]);
vcvtps2hf8(xm16, zword [r16+r17*4+0x40]);
vcvtps2hf8(xm24, zword [r24+r25*8+0x7f]);
vcvtps2hf8(xm0, xword_b [rax+rcx*1+0x10]);
vcvtps2hf8(xm8, yword_b [r8+r9*2+0x20]);
vcvtps2hf8(xm16, zword_b [r16+r17*4+0x40]);
vcvtps2hf8(xm0|k4|T_z, xword [rax+rcx*1+0x10]);
vcvtps2hf8(xm8|k5, zword_b [r8+r9*2+0x40]);
vcvtps2hf8(xm0|k4, xm8);
vcvtps2hf8(xm8|k5, xm16);
vcvtps2hf8(xm16|k6, xm24);
vcvtps2hf8(xm24|k7|T_z, xm0);
vcvtps2hf8(xm0|k4, ym8);
vcvtps2hf8(xm8|k5, ym16);
vcvtps2hf8(xm16|k6, ym24);
vcvtps2hf8(xm24|k7|T_z, ym0);
vcvtps2hf8(xm0|k4, zm8);
vcvtps2hf8(xm8|k5, zm16);
vcvtps2hf8(xm16|k6, zm24);
vcvtps2hf8(xm24|k7|T_z, zm0);

// vcvtps2hf8s: opCvt5 shape, dst always xm, src grows xm/ym/zm
vcvtps2hf8s(xm0, xm0);
vcvtps2hf8s(xm8, xm8);
vcvtps2hf8s(xm16, xm16);
vcvtps2hf8s(xm24, xm24);
vcvtps2hf8s(xm0, xm24);
vcvtps2hf8s(xm8, xm16);
vcvtps2hf8s(xm16, xm8);
vcvtps2hf8s(xm24, xm0);
vcvtps2hf8s(xm0, ym0);
vcvtps2hf8s(xm8, ym8);
vcvtps2hf8s(xm16, ym16);
vcvtps2hf8s(xm24, ym24);
vcvtps2hf8s(xm0, ym24);
vcvtps2hf8s(xm8, ym16);
vcvtps2hf8s(xm16, ym8);
vcvtps2hf8s(xm24, ym0);
vcvtps2hf8s(xm0, zm0);
vcvtps2hf8s(xm8, zm8);
vcvtps2hf8s(xm16, zm16);
vcvtps2hf8s(xm24, zm24);
vcvtps2hf8s(xm0, zm24);
vcvtps2hf8s(xm8, zm16);
vcvtps2hf8s(xm16, zm8);
vcvtps2hf8s(xm24, zm0);
vcvtps2hf8s(xm0, xword [rax+rcx*1+0x10]);
vcvtps2hf8s(xm8, yword [r8+r9*2+0x20]);
vcvtps2hf8s(xm16, zword [r16+r17*4+0x40]);
vcvtps2hf8s(xm24, zword [r24+r25*8+0x7f]);
vcvtps2hf8s(xm0, xword_b [rax+rcx*1+0x10]);
vcvtps2hf8s(xm8, yword_b [r8+r9*2+0x20]);
vcvtps2hf8s(xm16, zword_b [r16+r17*4+0x40]);
vcvtps2hf8s(xm0|k4|T_z, xword [rax+rcx*1+0x10]);
vcvtps2hf8s(xm8|k5, zword_b [r8+r9*2+0x40]);
vcvtps2hf8s(xm0|k4, xm8);
vcvtps2hf8s(xm8|k5, xm16);
vcvtps2hf8s(xm16|k6, xm24);
vcvtps2hf8s(xm24|k7|T_z, xm0);
vcvtps2hf8s(xm0|k4, ym8);
vcvtps2hf8s(xm8|k5, ym16);
vcvtps2hf8s(xm16|k6, ym24);
vcvtps2hf8s(xm24|k7|T_z, ym0);
vcvtps2hf8s(xm0|k4, zm8);
vcvtps2hf8s(xm8|k5, zm16);
vcvtps2hf8s(xm16|k6, zm24);
vcvtps2hf8s(xm24|k7|T_z, zm0);

// vcvtrops2hf8: opCvt5 shape, dst always xm, src grows xm/ym/zm
vcvtrops2hf8(xm0, xm0);
vcvtrops2hf8(xm8, xm8);
vcvtrops2hf8(xm16, xm16);
vcvtrops2hf8(xm24, xm24);
vcvtrops2hf8(xm0, xm24);
vcvtrops2hf8(xm8, xm16);
vcvtrops2hf8(xm16, xm8);
vcvtrops2hf8(xm24, xm0);
vcvtrops2hf8(xm0, ym0);
vcvtrops2hf8(xm8, ym8);
vcvtrops2hf8(xm16, ym16);
vcvtrops2hf8(xm24, ym24);
vcvtrops2hf8(xm0, ym24);
vcvtrops2hf8(xm8, ym16);
vcvtrops2hf8(xm16, ym8);
vcvtrops2hf8(xm24, ym0);
vcvtrops2hf8(xm0, zm0);
vcvtrops2hf8(xm8, zm8);
vcvtrops2hf8(xm16, zm16);
vcvtrops2hf8(xm24, zm24);
vcvtrops2hf8(xm0, zm24);
vcvtrops2hf8(xm8, zm16);
vcvtrops2hf8(xm16, zm8);
vcvtrops2hf8(xm24, zm0);
vcvtrops2hf8(xm0, xword [rax+rcx*1+0x10]);
vcvtrops2hf8(xm8, yword [r8+r9*2+0x20]);
vcvtrops2hf8(xm16, zword [r16+r17*4+0x40]);
vcvtrops2hf8(xm24, zword [r24+r25*8+0x7f]);
vcvtrops2hf8(xm0, xword_b [rax+rcx*1+0x10]);
vcvtrops2hf8(xm8, yword_b [r8+r9*2+0x20]);
vcvtrops2hf8(xm16, zword_b [r16+r17*4+0x40]);
vcvtrops2hf8(xm0|k4|T_z, xword [rax+rcx*1+0x10]);
vcvtrops2hf8(xm8|k5, zword_b [r8+r9*2+0x40]);
vcvtrops2hf8(xm0|k4, xm8);
vcvtrops2hf8(xm8|k5, xm16);
vcvtrops2hf8(xm16|k6, xm24);
vcvtrops2hf8(xm24|k7|T_z, xm0);
vcvtrops2hf8(xm0|k4, ym8);
vcvtrops2hf8(xm8|k5, ym16);
vcvtrops2hf8(xm16|k6, ym24);
vcvtrops2hf8(xm24|k7|T_z, ym0);
vcvtrops2hf8(xm0|k4, zm8);
vcvtrops2hf8(xm8|k5, zm16);
vcvtrops2hf8(xm16|k6, zm24);
vcvtrops2hf8(xm24|k7|T_z, zm0);

// vcvtrops2hf8s: opCvt5 shape, dst always xm, src grows xm/ym/zm
vcvtrops2hf8s(xm0, xm0);
vcvtrops2hf8s(xm8, xm8);
vcvtrops2hf8s(xm16, xm16);
vcvtrops2hf8s(xm24, xm24);
vcvtrops2hf8s(xm0, xm24);
vcvtrops2hf8s(xm8, xm16);
vcvtrops2hf8s(xm16, xm8);
vcvtrops2hf8s(xm24, xm0);
vcvtrops2hf8s(xm0, ym0);
vcvtrops2hf8s(xm8, ym8);
vcvtrops2hf8s(xm16, ym16);
vcvtrops2hf8s(xm24, ym24);
vcvtrops2hf8s(xm0, ym24);
vcvtrops2hf8s(xm8, ym16);
vcvtrops2hf8s(xm16, ym8);
vcvtrops2hf8s(xm24, ym0);
vcvtrops2hf8s(xm0, zm0);
vcvtrops2hf8s(xm8, zm8);
vcvtrops2hf8s(xm16, zm16);
vcvtrops2hf8s(xm24, zm24);
vcvtrops2hf8s(xm0, zm24);
vcvtrops2hf8s(xm8, zm16);
vcvtrops2hf8s(xm16, zm8);
vcvtrops2hf8s(xm24, zm0);
vcvtrops2hf8s(xm0, xword [rax+rcx*1+0x10]);
vcvtrops2hf8s(xm8, yword [r8+r9*2+0x20]);
vcvtrops2hf8s(xm16, zword [r16+r17*4+0x40]);
vcvtrops2hf8s(xm24, zword [r24+r25*8+0x7f]);
vcvtrops2hf8s(xm0, xword_b [rax+rcx*1+0x10]);
vcvtrops2hf8s(xm8, yword_b [r8+r9*2+0x20]);
vcvtrops2hf8s(xm16, zword_b [r16+r17*4+0x40]);
vcvtrops2hf8s(xm0|k4|T_z, xword [rax+rcx*1+0x10]);
vcvtrops2hf8s(xm8|k5, zword_b [r8+r9*2+0x40]);
vcvtrops2hf8s(xm0|k4, xm8);
vcvtrops2hf8s(xm8|k5, xm16);
vcvtrops2hf8s(xm16|k6, xm24);
vcvtrops2hf8s(xm24|k7|T_z, xm0);
vcvtrops2hf8s(xm0|k4, ym8);
vcvtrops2hf8s(xm8|k5, ym16);
vcvtrops2hf8s(xm16|k6, ym24);
vcvtrops2hf8s(xm24|k7|T_z, ym0);
vcvtrops2hf8s(xm0|k4, zm8);
vcvtrops2hf8s(xm8|k5, zm16);
vcvtrops2hf8s(xm16|k6, zm24);
vcvtrops2hf8s(xm24|k7|T_z, zm0);

// vcvtbiasps2bf8: dst fixed xm, bias/src grow together xm/ym/zm
vcvtbiasps2bf8(xm0, xm0, xm0);
vcvtbiasps2bf8(xm8, xm8, xm8);
vcvtbiasps2bf8(xm16, xm16, xm16);
vcvtbiasps2bf8(xm24, xm24, xm24);
vcvtbiasps2bf8(xm0, ym0, ym0);
vcvtbiasps2bf8(xm8, ym8, ym8);
vcvtbiasps2bf8(xm16, ym16, ym16);
vcvtbiasps2bf8(xm24, ym24, ym24);
vcvtbiasps2bf8(xm0, zm0, zm0);
vcvtbiasps2bf8(xm8, zm8, zm8);
vcvtbiasps2bf8(xm16, zm16, zm16);
vcvtbiasps2bf8(xm24, zm24, zm24);
vcvtbiasps2bf8(xm0, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2bf8(xm8, ym9, yword [r8+r9*2+0x20]);
vcvtbiasps2bf8(xm16, zm17, zword [r16+r17*4+0x40]);
vcvtbiasps2bf8(xm0, xm1, xword_b [rax+rcx*1+0x10]);
vcvtbiasps2bf8(xm8, ym9, yword_b [r8+r9*2+0x20]);
vcvtbiasps2bf8(xm16, zm17, zword_b [r16+r17*4+0x40]);
vcvtbiasps2bf8(xm0|k4|T_z, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2bf8(xm8|k5, zm9, zword_b [r8+r9*2+0x40]);
vcvtbiasps2bf8(xm0|k4, xm8, xm8);
vcvtbiasps2bf8(xm8|k5, xm16, xm16);
vcvtbiasps2bf8(xm16|k6, xm24, xm24);
vcvtbiasps2bf8(xm24|k7|T_z, xm0, xm0);
vcvtbiasps2bf8(xm0|k4, ym8, ym8);
vcvtbiasps2bf8(xm8|k5, ym16, ym16);
vcvtbiasps2bf8(xm16|k6, ym24, ym24);
vcvtbiasps2bf8(xm24|k7|T_z, ym0, ym0);
vcvtbiasps2bf8(xm0|k4, zm8, zm8);
vcvtbiasps2bf8(xm8|k5, zm16, zm16);
vcvtbiasps2bf8(xm16|k6, zm24, zm24);
vcvtbiasps2bf8(xm24|k7|T_z, zm0, zm0);

// vcvtbiasps2bf8s: dst fixed xm, bias/src grow together xm/ym/zm
vcvtbiasps2bf8s(xm0, xm0, xm0);
vcvtbiasps2bf8s(xm8, xm8, xm8);
vcvtbiasps2bf8s(xm16, xm16, xm16);
vcvtbiasps2bf8s(xm24, xm24, xm24);
vcvtbiasps2bf8s(xm0, ym0, ym0);
vcvtbiasps2bf8s(xm8, ym8, ym8);
vcvtbiasps2bf8s(xm16, ym16, ym16);
vcvtbiasps2bf8s(xm24, ym24, ym24);
vcvtbiasps2bf8s(xm0, zm0, zm0);
vcvtbiasps2bf8s(xm8, zm8, zm8);
vcvtbiasps2bf8s(xm16, zm16, zm16);
vcvtbiasps2bf8s(xm24, zm24, zm24);
vcvtbiasps2bf8s(xm0, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2bf8s(xm8, ym9, yword [r8+r9*2+0x20]);
vcvtbiasps2bf8s(xm16, zm17, zword [r16+r17*4+0x40]);
vcvtbiasps2bf8s(xm0, xm1, xword_b [rax+rcx*1+0x10]);
vcvtbiasps2bf8s(xm8, ym9, yword_b [r8+r9*2+0x20]);
vcvtbiasps2bf8s(xm16, zm17, zword_b [r16+r17*4+0x40]);
vcvtbiasps2bf8s(xm0|k4|T_z, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2bf8s(xm8|k5, zm9, zword_b [r8+r9*2+0x40]);
vcvtbiasps2bf8s(xm0|k4, xm8, xm8);
vcvtbiasps2bf8s(xm8|k5, xm16, xm16);
vcvtbiasps2bf8s(xm16|k6, xm24, xm24);
vcvtbiasps2bf8s(xm24|k7|T_z, xm0, xm0);
vcvtbiasps2bf8s(xm0|k4, ym8, ym8);
vcvtbiasps2bf8s(xm8|k5, ym16, ym16);
vcvtbiasps2bf8s(xm16|k6, ym24, ym24);
vcvtbiasps2bf8s(xm24|k7|T_z, ym0, ym0);
vcvtbiasps2bf8s(xm0|k4, zm8, zm8);
vcvtbiasps2bf8s(xm8|k5, zm16, zm16);
vcvtbiasps2bf8s(xm16|k6, zm24, zm24);
vcvtbiasps2bf8s(xm24|k7|T_z, zm0, zm0);

// vcvtbiasps2hf8: dst fixed xm, bias/src grow together xm/ym/zm
vcvtbiasps2hf8(xm0, xm0, xm0);
vcvtbiasps2hf8(xm8, xm8, xm8);
vcvtbiasps2hf8(xm16, xm16, xm16);
vcvtbiasps2hf8(xm24, xm24, xm24);
vcvtbiasps2hf8(xm0, ym0, ym0);
vcvtbiasps2hf8(xm8, ym8, ym8);
vcvtbiasps2hf8(xm16, ym16, ym16);
vcvtbiasps2hf8(xm24, ym24, ym24);
vcvtbiasps2hf8(xm0, zm0, zm0);
vcvtbiasps2hf8(xm8, zm8, zm8);
vcvtbiasps2hf8(xm16, zm16, zm16);
vcvtbiasps2hf8(xm24, zm24, zm24);
vcvtbiasps2hf8(xm0, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2hf8(xm8, ym9, yword [r8+r9*2+0x20]);
vcvtbiasps2hf8(xm16, zm17, zword [r16+r17*4+0x40]);
vcvtbiasps2hf8(xm0, xm1, xword_b [rax+rcx*1+0x10]);
vcvtbiasps2hf8(xm8, ym9, yword_b [r8+r9*2+0x20]);
vcvtbiasps2hf8(xm16, zm17, zword_b [r16+r17*4+0x40]);
vcvtbiasps2hf8(xm0|k4|T_z, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2hf8(xm8|k5, zm9, zword_b [r8+r9*2+0x40]);
vcvtbiasps2hf8(xm0|k4, xm8, xm8);
vcvtbiasps2hf8(xm8|k5, xm16, xm16);
vcvtbiasps2hf8(xm16|k6, xm24, xm24);
vcvtbiasps2hf8(xm24|k7|T_z, xm0, xm0);
vcvtbiasps2hf8(xm0|k4, ym8, ym8);
vcvtbiasps2hf8(xm8|k5, ym16, ym16);
vcvtbiasps2hf8(xm16|k6, ym24, ym24);
vcvtbiasps2hf8(xm24|k7|T_z, ym0, ym0);
vcvtbiasps2hf8(xm0|k4, zm8, zm8);
vcvtbiasps2hf8(xm8|k5, zm16, zm16);
vcvtbiasps2hf8(xm16|k6, zm24, zm24);
vcvtbiasps2hf8(xm24|k7|T_z, zm0, zm0);

// vcvtbiasps2hf8s: dst fixed xm, bias/src grow together xm/ym/zm
vcvtbiasps2hf8s(xm0, xm0, xm0);
vcvtbiasps2hf8s(xm8, xm8, xm8);
vcvtbiasps2hf8s(xm16, xm16, xm16);
vcvtbiasps2hf8s(xm24, xm24, xm24);
vcvtbiasps2hf8s(xm0, ym0, ym0);
vcvtbiasps2hf8s(xm8, ym8, ym8);
vcvtbiasps2hf8s(xm16, ym16, ym16);
vcvtbiasps2hf8s(xm24, ym24, ym24);
vcvtbiasps2hf8s(xm0, zm0, zm0);
vcvtbiasps2hf8s(xm8, zm8, zm8);
vcvtbiasps2hf8s(xm16, zm16, zm16);
vcvtbiasps2hf8s(xm24, zm24, zm24);
vcvtbiasps2hf8s(xm0, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2hf8s(xm8, ym9, yword [r8+r9*2+0x20]);
vcvtbiasps2hf8s(xm16, zm17, zword [r16+r17*4+0x40]);
vcvtbiasps2hf8s(xm0, xm1, xword_b [rax+rcx*1+0x10]);
vcvtbiasps2hf8s(xm8, ym9, yword_b [r8+r9*2+0x20]);
vcvtbiasps2hf8s(xm16, zm17, zword_b [r16+r17*4+0x40]);
vcvtbiasps2hf8s(xm0|k4|T_z, xm1, xword [rax+rcx*1+0x10]);
vcvtbiasps2hf8s(xm8|k5, zm9, zword_b [r8+r9*2+0x40]);
vcvtbiasps2hf8s(xm0|k4, xm8, xm8);
vcvtbiasps2hf8s(xm8|k5, xm16, xm16);
vcvtbiasps2hf8s(xm16|k6, xm24, xm24);
vcvtbiasps2hf8s(xm24|k7|T_z, xm0, xm0);
vcvtbiasps2hf8s(xm0|k4, ym8, ym8);
vcvtbiasps2hf8s(xm8|k5, ym16, ym16);
vcvtbiasps2hf8s(xm16|k6, ym24, ym24);
vcvtbiasps2hf8s(xm24|k7|T_z, ym0, ym0);
vcvtbiasps2hf8s(xm0|k4, zm8, zm8);
vcvtbiasps2hf8s(xm8|k5, zm16, zm16);
vcvtbiasps2hf8s(xm16|k6, zm24, zm24);
vcvtbiasps2hf8s(xm24|k7|T_z, zm0, zm0);

// vcvtbf82ps: dst grows xm/ym/zm, register-form src fixed xm
vcvtbf82ps(xm0, xm24);
vcvtbf82ps(xm8, xm0);
vcvtbf82ps(xm16, xm8);
vcvtbf82ps(xm24, xm0);
vcvtbf82ps(ym0, xm8);
vcvtbf82ps(ym8, xm16);
vcvtbf82ps(ym16, xm24);
vcvtbf82ps(ym24, xm0);
vcvtbf82ps(zm0, xm16);
vcvtbf82ps(zm8, xm24);
vcvtbf82ps(zm16, xm0);
vcvtbf82ps(zm24, xm8);
vcvtbf82ps(xm0, dword [rax+rcx*1+0x10]);
vcvtbf82ps(ym8, qword [r8+r9*2+0x20]);
vcvtbf82ps(zm16, xword [r16+r17*4+0x40]);
vcvtbf82ps(xm0|k4|T_z, dword [rax+rcx*1+0x10]);
vcvtbf82ps(zm16|k6, xword [r16+r17*4+0x40]);
vcvtbf82ps(xm0|k4, xm8);
vcvtbf82ps(ym8|k5, xm16);
vcvtbf82ps(zm16|k6|T_z, xm24);
vcvtbf82ps(zm24|k7, xm8);

// vcvthf82ps: dst grows xm/ym/zm, register-form src fixed xm
vcvthf82ps(xm0, xm24);
vcvthf82ps(xm8, xm0);
vcvthf82ps(xm16, xm8);
vcvthf82ps(xm24, xm0);
vcvthf82ps(ym0, xm8);
vcvthf82ps(ym8, xm16);
vcvthf82ps(ym16, xm24);
vcvthf82ps(ym24, xm0);
vcvthf82ps(zm0, xm16);
vcvthf82ps(zm8, xm24);
vcvthf82ps(zm16, xm0);
vcvthf82ps(zm24, xm8);
vcvthf82ps(xm0, dword [rax+rcx*1+0x10]);
vcvthf82ps(ym8, qword [r8+r9*2+0x20]);
vcvthf82ps(zm16, xword [r16+r17*4+0x40]);
vcvthf82ps(xm0|k4|T_z, dword [rax+rcx*1+0x10]);
vcvthf82ps(zm16|k6, xword [r16+r17*4+0x40]);
vcvthf82ps(xm0|k4, xm8);
vcvthf82ps(ym8|k5, xm16);
vcvthf82ps(zm16|k6|T_z, xm24);
vcvthf82ps(zm24|k7, xm8);

// vcvtbf42hf8: dst grows xm/ym/zm; register src is xm at 128/256, ym at 512
vcvtbf42hf8(xm0, xm24);
vcvtbf42hf8(xm8, xm0);
vcvtbf42hf8(xm16, xm8);
vcvtbf42hf8(xm24, xm0);
vcvtbf42hf8(ym0, xm8);
vcvtbf42hf8(ym8, xm16);
vcvtbf42hf8(ym16, xm24);
vcvtbf42hf8(ym24, xm0);
vcvtbf42hf8(zm0, ym16);
vcvtbf42hf8(zm8, ym24);
vcvtbf42hf8(zm16, ym0);
vcvtbf42hf8(zm24, ym8);
vcvtbf42hf8(xm0, qword [rax+rcx*1+0x10]);
vcvtbf42hf8(ym8, xword [r8+r9*2+0x20]);
vcvtbf42hf8(zm16, yword [r16+r17*4+0x40]);
vcvtbf42hf8(xm0|k4|T_z, qword [rax+rcx*1+0x10]);
vcvtbf42hf8(zm16|k6, yword [r16+r17*4+0x40]);
vcvtbf42hf8(xm0|k4, xm8);
vcvtbf42hf8(ym8|k5, xm16);
vcvtbf42hf8(zm16|k6|T_z, ym24);
vcvtbf42hf8(zm24|k7, ym0);

// vcvtbf62hf8: same-VL reinterpret convert, register-only, masking-eligible
vcvtbf62hf8(xm0, xm0);
vcvtbf62hf8(xm8, xm8);
vcvtbf62hf8(xm16, xm16);
vcvtbf62hf8(xm24, xm24);
vcvtbf62hf8(ym0, ym0);
vcvtbf62hf8(ym8, ym8);
vcvtbf62hf8(ym16, ym16);
vcvtbf62hf8(ym24, ym24);
vcvtbf62hf8(zm0, zm0);
vcvtbf62hf8(zm8, zm8);
vcvtbf62hf8(zm16, zm16);
vcvtbf62hf8(zm24, zm24);
vcvtbf62hf8(xm0|k4, xm8);
vcvtbf62hf8(ym8|k5, ym16);
vcvtbf62hf8(zm16|k6|T_z, zm24);
vcvtbf62hf8(zm24|k7, zm16);

// vcvthf62hf8: same-VL reinterpret convert, register-only, masking-eligible
vcvthf62hf8(xm0, xm0);
vcvthf62hf8(xm8, xm8);
vcvthf62hf8(xm16, xm16);
vcvthf62hf8(xm24, xm24);
vcvthf62hf8(ym0, ym0);
vcvthf62hf8(ym8, ym8);
vcvthf62hf8(ym16, ym16);
vcvthf62hf8(ym24, ym24);
vcvthf62hf8(zm0, zm0);
vcvthf62hf8(zm8, zm8);
vcvthf62hf8(zm16, zm16);
vcvthf62hf8(zm24, zm24);
vcvthf62hf8(xm0|k4, xm8);
vcvthf62hf8(ym8|k5, ym16);
vcvthf62hf8(zm16|k6|T_z, zm24);
vcvthf62hf8(zm24|k7, zm16);

// vcvtbf82bf6s: same-VL narrowing convert, register-only, no masking form in spec table
vcvtbf82bf6s(xm0, xm0);
vcvtbf82bf6s(xm8, xm8);
vcvtbf82bf6s(xm16, xm16);
vcvtbf82bf6s(xm24, xm24);
vcvtbf82bf6s(ym0, ym0);
vcvtbf82bf6s(ym8, ym8);
vcvtbf82bf6s(ym16, ym16);
vcvtbf82bf6s(ym24, ym24);
vcvtbf82bf6s(zm0, zm0);
vcvtbf82bf6s(zm8, zm8);
vcvtbf82bf6s(zm16, zm16);
vcvtbf82bf6s(zm24, zm24);

// vcvthf82hf6s: same-VL narrowing convert, register-only, no masking form in spec table
vcvthf82hf6s(xm0, xm0);
vcvthf82hf6s(xm8, xm8);
vcvthf82hf6s(xm16, xm16);
vcvthf82hf6s(xm24, xm24);
vcvthf82hf6s(ym0, ym0);
vcvthf82hf6s(ym8, ym8);
vcvthf82hf6s(ym16, ym16);
vcvthf82hf6s(ym24, ym24);
vcvthf82hf6s(zm0, zm0);
vcvthf82hf6s(zm8, zm8);
vcvthf82hf6s(zm16, zm16);
vcvthf82hf6s(zm24, zm24);

// vcvtbf82bf4s: narrow-store, dst(mem-or-narrower-reg)/src(wider-reg) grow together
vcvtbf82bf4s(xm0, xm24);
vcvtbf82bf4s(xm8, xm0);
vcvtbf82bf4s(xm16, xm8);
vcvtbf82bf4s(xm24, xm0);
vcvtbf82bf4s(xm0, ym8);
vcvtbf82bf4s(xm8, ym16);
vcvtbf82bf4s(xm16, ym24);
vcvtbf82bf4s(xm24, ym0);
vcvtbf82bf4s(ym0, zm16);
vcvtbf82bf4s(ym8, zm24);
vcvtbf82bf4s(ym16, zm0);
vcvtbf82bf4s(ym24, zm8);
vcvtbf82bf4s(qword [rax+rcx*1+0x10], xm0);
vcvtbf82bf4s(xword [r8+r9*2+0x20], ym8);
vcvtbf82bf4s(yword [r16+r17*4+0x40], zm16);

// vcvthf82bf4s: narrow-store, dst(mem-or-narrower-reg)/src(wider-reg) grow together
vcvthf82bf4s(xm0, xm24);
vcvthf82bf4s(xm8, xm0);
vcvthf82bf4s(xm16, xm8);
vcvthf82bf4s(xm24, xm0);
vcvthf82bf4s(xm0, ym8);
vcvthf82bf4s(xm8, ym16);
vcvthf82bf4s(xm16, ym24);
vcvthf82bf4s(xm24, ym0);
vcvthf82bf4s(ym0, zm16);
vcvthf82bf4s(ym8, zm24);
vcvthf82bf4s(ym16, zm0);
vcvthf82bf4s(ym24, zm8);
vcvthf82bf4s(qword [rax+rcx*1+0x10], xm0);
vcvthf82bf4s(xword [r8+r9*2+0x20], ym8);
vcvthf82bf4s(yword [r16+r17*4+0x40], zm16);

// vunpackb: opAVX_X_XM_IMM shape, masking-eligible, all VLs
vunpackb(xm0, xm24, 0x00);
vunpackb(xm8, xm0, 0x08);
vunpackb(xm16, xm8, 0x10);
vunpackb(xm24, xm0, 0x18);
vunpackb(ym0, ym8, 0x00);
vunpackb(ym8, ym16, 0x08);
vunpackb(ym16, ym24, 0x10);
vunpackb(ym24, ym0, 0x18);
vunpackb(zm0, zm16, 0x00);
vunpackb(zm8, zm24, 0x08);
vunpackb(zm16, zm0, 0x10);
vunpackb(zm24, zm8, 0x18);
vunpackb(xm0, xword [rax+rcx*1+0x10], 0x11);
vunpackb(ym8, yword [r8+r9*2+0x20], 0x22);
vunpackb(zm16, zword [r16+r17*4+0x40], 0x33);
vunpackb(xm0|k4, xm8, 0x01);
vunpackb(ym8|k5, ym16, 0x02);
vunpackb(zm16|k6|T_z, zm24, 0x03);
vunpackb(zm24|k7, zm8, 0x04);

// vpmovssdb: narrow-store, dst register form fixed xm, src grows xm/ym/zm
vpmovssdb(xm0, xm24);
vpmovssdb(xm8, xm0);
vpmovssdb(xm16, xm8);
vpmovssdb(xm24, xm0);
vpmovssdb(xm0, ym8);
vpmovssdb(xm8, ym16);
vpmovssdb(xm16, ym24);
vpmovssdb(xm24, ym0);
vpmovssdb(xm0, zm16);
vpmovssdb(xm8, zm24);
vpmovssdb(xm16, zm0);
vpmovssdb(xm24, zm8);
vpmovssdb(dword [rax+rcx*1+0x10], xm0);
vpmovssdb(qword [r8+r9*2+0x20], ym8);
vpmovssdb(xword [r16+r17*4+0x40], zm16);
vpmovssdb(dword [rax+rcx*1+0x10]|k4, xm0);
vpmovssdb(xword [r16+r17*4+0x40]|k5, zm16);

