// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_I_mb_cabac
static noinline void CAFUNC(parse_I_mb, int mb_type_or_ctxIdx)
{
	static const uint8_t me_intra[48] = {174, 173, 172, 0, 45, 169, 165, 141, 44, 168, 164, 140, 46, 170, 166, 142, 1, 40, 36, 136, 132, 41, 37, 137, 133, 42, 38, 138, 134, 32, 8, 4, 128, 33, 9, 5, 129, 12, 160, 13, 161, 2, 34, 10, 6, 130, 14, 162};
	
	// Intra-specific initialisations
	#if CABAC
		ctx->nC_inc_v[0] = ctx->nC_inc_v[1] = ctx->nC_inc_v[2] = (i8x16){};
		if (ctx->unavail4x4[0] & 1) {
			mb->bits[1] |= 0x111111; // FIXME 4:2:2
			ctx->nC_inc_v[0] += (i8x16){1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0};
			ctx->nC_inc_v[1] += (i8x16){1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			ctx->inc.coded_block_flags_16x16_s |= 0x010101;
		}
		if (ctx->unavail4x4[0] & 2) {
			mb->bits[1] |= 0x424242;
			ctx->nC_inc_v[0] += (i8x16){2, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			ctx->nC_inc_v[1] += (i8x16){2, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			ctx->inc.coded_block_flags_16x16_s |= 0x020202;
		}
	#endif
	mb->mbIsInterFlag = 0;
	mb->f.inter_eqs_s = little_endian32(0x1b5fbbff);
	mb->refIdx_l = -1;
	mb->refPic_l = -1;
	mb->mvs_v[0] = mb->mvs_v[1] = mb->mvs_v[2] = mb->mvs_v[3] = mb->mvs_v[4] = mb->mvs_v[5] = mb->mvs_v[6] = mb->mvs_v[7] = (i16x8){};
	
	// I_NxN
	if (CACOND(mb_type_or_ctxIdx == 0, !get_ae(ctx, mb_type_or_ctxIdx))) {
		#if CABAC
			mb->f.mb_type_I_NxN = 1;
			log_mb(ctx, (mb_type_or_ctxIdx == 17) ? "    mb_type: 5\n" : // in P slice
								 (mb_type_or_ctxIdx == 32) ? "    mb_type: 23\n" : // in B slice
																	  "    mb_type: 0\n"); // in I slice
		#endif
		
		// 7.3.5, 7.4.5, 9.3.3.1.1.10 and table 9-34
		int transform_size_8x8_flag = 0;
		if (ctx->t.pps.transform_8x8_mode_flag) {
			transform_size_8x8_flag = CACOND(get_u1(&ctx->t._gb), get_ae(ctx, 399 + ctx->inc.transform_size_8x8_flag));
			log_mb(ctx, "    transform_size_8x8_flag: %u\n", transform_size_8x8_flag);
		}
		
		mb->Intra4x4PredMode_v = (i8x16){-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2}; // default values when A/B is unavailable
		if (transform_size_8x8_flag) {
			mb->f.transform_size_8x8_flag = transform_size_8x8_flag;
			log_mb(ctx, "    rem_intra8x8_pred_modes: [");
			for (int i = 0; i < 16; i += 4)
				mb->Intra4x4PredMode[i + 1] = mb->Intra4x4PredMode[i + 2] = mb->Intra4x4PredMode[i + 3] = CACALL(parse_intraNxN_pred_mode, i);
			log_mb(ctx, "]\n    Intra8x8PredModes: [%u,%u,%u,%u]\n",
				mb->Intra4x4PredMode[0], mb->Intra4x4PredMode[4], mb->Intra4x4PredMode[8], mb->Intra4x4PredMode[12]);
		} else {
			log_mb(ctx, "    rem_intra4x4_pred_modes: [");
			for (int i = 0; i < 16; i++)
				mb->Intra4x4PredMode[i] = CACALL(parse_intraNxN_pred_mode, i);
			log_mb(ctx, "]\n    Intra4x4PredModes: [%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u]\n",
				mb->Intra4x4PredMode[0], mb->Intra4x4PredMode[1], mb->Intra4x4PredMode[2], mb->Intra4x4PredMode[3],
				mb->Intra4x4PredMode[4], mb->Intra4x4PredMode[5], mb->Intra4x4PredMode[6], mb->Intra4x4PredMode[7],
				mb->Intra4x4PredMode[8], mb->Intra4x4PredMode[9], mb->Intra4x4PredMode[10], mb->Intra4x4PredMode[11],
				mb->Intra4x4PredMode[12], mb->Intra4x4PredMode[13], mb->Intra4x4PredMode[14], mb->Intra4x4PredMode[15]);
		}
		
		CACALL(parse_intra_chroma_pred_mode);
		CACALL(parse_coded_block_pattern, me_intra);
		CAJUMP(parse_NxN_residual);
	
	// Intra_16x16
	} else if (__builtin_expect(CACOND(mb_type_or_ctxIdx < 25, !cabac_terminate(ctx)), 1)) {
		#if !CABAC
			int mb_type = mb_type_or_ctxIdx - 1;
			mb->bits[0] = mb_type > 11 ? 0xac : 0; // zeroes ref_idx_nz as byproduct
			mb_type = mb_type > 11 ? mb_type - 12 : mb_type;
			mb->f.CodedBlockPatternChromaDC = mb_type > 3;
			mb->f.CodedBlockPatternChromaAC = mb_type >> 3;
			int mode = mb_type & 3;
		#else
			int ctxIdx = max(mb_type_or_ctxIdx, 5);
			mb->bits[0] = get_ae(ctx, ctxIdx + 1) ? 0xac : 0; // zeroes ref_idx_nz as byproduct
			int CodedBlockPatternChromaDC = get_ae(ctx, ctxIdx + 2);
			ctxIdx = max(ctxIdx, 6);
			if (CodedBlockPatternChromaDC) {
				mb->f.CodedBlockPatternChromaDC = 1;
				mb->f.CodedBlockPatternChromaAC = get_ae(ctx, ctxIdx + 2);
			}
			int mode = get_ae(ctx, ctxIdx + 3) << 1;
			mode += get_ae(ctx, max(ctxIdx + 3, 10));
			log_mb(ctx, "    mb_type: %u\n", (mb->bits[0] & 12) +
				(mb->f.CodedBlockPatternChromaDC + mb->f.CodedBlockPatternChromaAC) * 4 +
				mode + (ctxIdx == 17 ? 6 : ctxIdx == 32 ? 24 : 1));
		#endif
		
		// decode the samples before parsing residuals
		static const int8_t Intra16x16Modes[4][4] = {
			{I16x16_V_8 , I16x16_V_8  , I16x16_DCB_8, I16x16_DCAB_8},
			{I16x16_H_8 , I16x16_DCA_8, I16x16_H_8  , I16x16_DCAB_8},
			{I16x16_DC_8, I16x16_DCA_8, I16x16_DCB_8, I16x16_DCAB_8},
			{I16x16_P_8 , I16x16_DCA_8, I16x16_DCB_8, I16x16_DCAB_8},
		};
		mb->Intra4x4PredMode_v = (i8x16){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
		decode_intra16x16(Intra16x16Modes[mode][ctx->unavail4x4[0] & 3], ctx->samples_mb[0], ctx->t.stride[0], ctx->t.samples_clip_v[0]); // FIXME 4:4:4
		CACALL(parse_intra_chroma_pred_mode);
		CAJUMP(parse_Intra16x16_residual);
		
	// I_PCM
	} else {
		#if !CABAC
			unsigned bits = (SIZE_BIT - 1 - ctz(ctx->t._gb.lsb_cache)) & 7;
			ctx->t._gb.msb_cache = shld(ctx->t._gb.lsb_cache, ctx->t._gb.msb_cache, bits);
			ctx->t._gb.lsb_cache = ctx->t._gb.lsb_cache << bits;
		#else
			log_mb(ctx, (mb_type_or_ctxIdx == 17) ? "    mb_type: 30\n" : (mb_type_or_ctxIdx == 32) ? "    mb_type: 48\n" : "    mb_type: 25\n");
		#endif
		
		ctx->mb_qp_delta_nz = 0;
		mb->f.v |= flags_twice.v; // ChromaDC, ChromaAC and flags_16x16, just what we need :)
		mb->QP_s = (i8x4){0, ctx->QP_C[0][0], ctx->QP_C[1][0]};
		mb->bits_l = (uint64_t)(i32x2){0xac, 0xacacac}; // FIXME 4:2:2
		mb->nC_v[0] = mb->nC_v[1] = mb->nC_v[2] = CACOND(
			((i8x16){16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16}),
			((i8x16){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}));
		mb->Intra4x4PredMode_v = (i8x16){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
		
		// PCM is so rare that it should be compact rather than fast
		int MbWidth = 16, y = 16;
		log_mb(ctx, "    pcm_samples:\n"
			"      bits_Y: %u\n"
			"      bits_C: %u\n",
			ctz(ctx->t.samples_clip[0][0] + 1), ctz(ctx->t.samples_clip[1][0] + 1));
		for (int iYCbCr = 0; iYCbCr < 3; iYCbCr++) {
			log_mb(ctx, "      %s: [", (const char *)"Y\0\0Cb\0Cr" + iYCbCr * 3);
			int BitDepth = ctz(ctx->t.samples_clip[iYCbCr][0] + 1);
			for (uint8_t *p = ctx->samples_mb[iYCbCr]; y-- > 0; p += ctx->t.stride[iYCbCr]) {
				if (BitDepth == 8) {
					((uint32_t *)p)[0] = big_endian32(get_uv(&ctx->t._gb, 32));
					((uint32_t *)p)[1] = big_endian32(get_uv(&ctx->t._gb, 32));
					log_mb(ctx, "%u,%u,%u,%u,%u,%u,%u,%u,", p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
					if (MbWidth == 16) {
						((uint32_t *)p)[2] = big_endian32(get_uv(&ctx->t._gb, 32));
						((uint32_t *)p)[3] = big_endian32(get_uv(&ctx->t._gb, 32));
						log_mb(ctx, "%u,%u,%u,%u,%u,%u,%u,%u,", p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
					}
				} else for (int x = 0; x < MbWidth; x++) {
					((uint16_t *)p)[x] = get_uv(&ctx->t._gb, BitDepth);
					log_mb(ctx, "%u,", ((uint16_t *)p)[x]);
				}
			}
			log_mb(ctx, "]\n");
			MbWidth = (ctx->t.ChromaArrayType < 3) ? 8 : 16;
			y = (int8_t[4]){0, 8, 16, 16}[ctx->t.ChromaArrayType];
		}
		#if CABAC
			cabac_start(ctx);
		#endif
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, 0x710(%rdi)
vmovdqa %ymm0, 0x700(%rdi)
movb 0x6d0(%rdi), %al
testb $0x1, %al
je 0x2a021
movq 0x680(%rbx), %rax
orl $0x111111, 0xc(%rax)    # imm = 0x111111
vmovdqa 0x700(%rbx), %xmm0
vpaddb 0x38af(%rip), %xmm0, %xmm0 # 0x2d8a0
vmovdqa %xmm0, 0x700(%rbx)
vmovdqa 0x710(%rbx), %xmm0
vpaddb 0x38a7(%rip), %xmm0, %xmm0 # 0x2d8b0
vmovdqa %xmm0, 0x710(%rbx)
orl $0x10101, 0x6c8(%rbx)   # imm = 0x10101
movb 0x6d0(%rbx), %al
testb $0x2, %al
je 0x2a065
movq 0x680(%rbx), %rax
orl $0x424242, 0xc(%rax)    # imm = 0x424242
vmovq 0x3885(%rip), %xmm0     # 0x2d8c0
vpaddb 0x700(%rbx), %xmm0, %xmm1
vmovdqa %xmm1, 0x700(%rbx)
vpaddb 0x710(%rbx), %xmm0, %xmm0
vmovdqa %xmm0, 0x710(%rbx)
orl $0x20202, 0x6c8(%rbx)   # imm = 0x20202
movq 0x680(%rbx), %rax
movb $0x0, 0x2(%rax)
movl $0x1b5fbbff, 0x2c(%rax) # imm = 0x1B5FBBFF
movq 0x680(%rbx), %rax
orq $-0x1, 0x10(%rax)
movq 0x680(%rbx), %rax
orq $-0x1, 0x18(%rax)
movq 0x680(%rbx), %rax
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x120(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0x110(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0x100(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0xf0(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0xe0(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0xd0(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0xc0(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0xb0(%rax)
movq %rbx, %rdi
movl %ebp, %esi
vzeroupper
callq 0x2aced
testl %eax, %eax
je 0x2a4ab
movq %rbx, %rdi
callq 0x2ac69
testl %eax, %eax
jne 0x2a800
cmpl $0x6, %ebp
pushq $0x5
popq %r14
cmovgel %ebp, %r14d
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x2aced
testl %eax, %eax
movl $0xac, %ecx
cmovel %eax, %ecx
movq 0x680(%rbx), %rax
movl %ecx, 0x8(%rax)
addl $0x2, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2aced
cmpl $0x7, %ebp
pushq $0x6
popq %r12
movl %r12d, %r14d
cmovgel %ebp, %r14d
testl %eax, %eax
je 0x2a19d
movq 0x680(%rbx), %rax
movb $0x1, 0x26(%rax)
leal 0x2(%r14), %esi
movq %rbx, %rdi
callq 0x2aced
movq 0x680(%rbx), %rcx
movb %al, 0x27(%rcx)
addl $0x3, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2aced
movl %eax, %r15d
cmpl $0xb, %r14d
pushq $0xa
popq %rsi
cmovael %r14d, %esi
movq %rbx, %rdi
callq 0x2aced
leal (%rax,%r15,2), %r14d
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a237
pushq $0x1
popq %rcx
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %edx           # imm = 0x1000
subl %eax, %edx
movzwl %dx, %esi
movq 0x680(%rbx), %rax
movl 0x8(%rax), %edx
andl $0xc, %edx
movsbl 0x26(%rax), %r8d
movsbl 0x27(%rax), %eax
addl %r8d, %eax
cmpl $0x20, %ebp
pushq $0x18
popq %r8
cmovnel %ecx, %r8d
cmpl $0x11, %ebp
cmovel %r12d, %r8d
addl %r14d, %r8d
addl %edx, %r8d
leal (%r8,%rax,4), %ecx
leaq 0xa3b5(%rip), %rdx      # 0x345de
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
movq 0x680(%rbx), %rax
vpbroadcastb 0x7596(%rip), %xmm0 # 0x317dd
vmovdqa %xmm0, 0x30(%rax)
movl %r14d, %eax
movzbl 0x6d0(%rbx), %ecx
andl $0x3, %ecx
leaq 0x3750(%rip), %rdx      # 0x2d9b0
leaq (%rdx,%rax,4), %rax
movsbl (%rcx,%rax), %edi
movq 0x668(%rbx), %rsi
movzwl 0x34(%rbx), %edx
callq 0x2923e
movq %rbx, %rdi
callq 0x2be59
movq %rbx, %rdi
callq 0x2b895
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a2c1
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0xa3d0(%rip), %rdx      # 0x34683
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
leaq 0x700(%rbx), %rbp
vmovaps 0x3230(%rip), %xmm0     # 0x2d500
vmovaps %xmm0, 0x1aa0(%rbx)
vmovaps 0x35f0(%rip), %xmm0     # 0x2d8d0
vmovaps %xmm0, 0x1a60(%rbx)
vmovaps %xmm0, 0x1a20(%rbx)
leaq 0x1ba0(%rbx), %rax
movq %rax, 0x18(%rsp)
movq $0x0, (%rsp)
movabsq $0x909080706, %rax      # imm = 0x909080706
vmovq %rax, %xmm0
vmovdqa %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x2a609
movq %r15, %r14
shlq $0x4, %r14
leaq 0x924c(%rip), %rax      # 0x33580
movq (%r14,%rax), %rax
movq %rax, 0x1a10(%rbx)
cwtl
movsbl 0x6c8(%rbx,%r15), %esi
addl %eax, %esi
movq %rbx, %rdi
vzeroupper
callq 0x2aced
testl %eax, %eax
je 0x2a390
movq 0x680(%rbx), %rax
movb $0x1, 0x28(%rax,%r15)
movabsq $0x909080706, %rax      # imm = 0x909080706
movq %rax, 0x1a18(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
pushq $0xf
popq %rdx
callq 0x2b970
movq %rbx, %rdi
movl %r15d, %esi
callq 0x29bab
movq 0x680(%rbx), %rax
testb $0x20, 0x8(%rax)
jne 0x2a3ca
movq 0x18(%rsp), %rax
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %ymm0, 0x20(%rax)
vmovdqa %ymm0, (%rax)
incq %r15
addq $0x10, (%rsp)
addq $0x10, %rbp
cmpb $0x2, 0x2a(%rbx)
jg 0x2a31c
jmp 0x2a61b
leaq 0x91df(%rip), %rax      # 0x335b0
vmovq (%r14,%rax), %xmm0
vpunpcklqdq 0x20(%rsp), %xmm0, %xmm0 # xmm0 = xmm0[0],mem[0]
vmovdqa %xmm0, 0x1a10(%rbx)
xorl %r12d, %r12d
cmpq $0x10, %r12
je 0x2a39d
leaq 0x355b(%rip), %rax      # 0x2d950
movsbq (%r12,%rax), %rax
movzwl 0x34(%rbx,%r15,2), %ecx
imulq %rax, %rcx
addq 0x668(%rbx,%r15,8), %rcx
leaq 0x352d(%rip), %rax      # 0x2d940
movsbq (%r12,%rax), %r13
addq %rcx, %r13
movq 0x680(%rbx), %rax
addq %r14, %rax
movswq 0xb40(%rbx,%r12,2), %rcx
movsbl 0x40(%rcx,%rax), %ecx
movslq 0xb80(%rbx,%r12,4), %rdx
movsbl 0x40(%rdx,%rax), %eax
movswl 0x1a10(%rbx), %edx
addl %ecx, %edx
movsbl (%rbp,%r12), %ecx
leal (%rdx,%rax,2), %esi
addl %ecx, %esi
movq %rbx, %rdi
callq 0x2aced
testl %eax, %eax
je 0x2a492
movq 0x680(%rbx), %rax
addq (%rsp), %rax
movb $0x1, 0x40(%r12,%rax)
movq %rbx, %rdi
pushq $0x1
popq %rsi
pushq $0xf
popq %rdx
callq 0x2b970
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movq %r13, %rcx
callq 0x26dd4
jmp 0x2a4a3
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movq %r13, %rcx
callq 0x2863a
incq %r12
jmp 0x2a3e8
movq 0x680(%rbx), %rax
movb $0x1, 0x22(%rax)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a50b
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
cmpl $0x20, %ebp
leaq 0xa3bc(%rip), %rax      # 0x348a0
leaq 0xa20d(%rip), %rcx      # 0x346f8
cmoveq %rax, %rcx
cmpl $0x11, %ebp
leaq 0xa397(%rip), %rdx      # 0x34890
cmovneq %rcx, %rdx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
cmpb $0x0, 0x22a(%rbx)
je 0x2a691
movsbl 0x6c4(%rbx), %esi
addl $0x18f, %esi            # imm = 0x18F
movq %rbx, %rdi
callq 0x2aced
movl %eax, %ebp
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a56a
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0xa0eb(%rip), %rdx      # 0x34645
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
movq 0x680(%rbx), %rax
vpbroadcastb 0x7264(%rip), %xmm0 # 0x317de
vmovdqa %xmm0, 0x30(%rax)
testl %ebp, %ebp
je 0x2a6a6
movq 0x680(%rbx), %rax
movb $0x1, 0x24(%rax)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a5cb
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0xa14b(%rip), %rdx      # 0x34708
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
xorl %r14d, %r14d
cmpq $0x10, %r14
jae 0x2a634
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2bd78
movq 0x680(%rbx), %rcx
movb %al, 0x33(%rcx,%r14)
movq 0x680(%rbx), %rcx
movb %al, 0x32(%rcx,%r14)
movq 0x680(%rbx), %rcx
movb %al, 0x31(%rcx,%r14)
addq $0x4, %r14
jmp 0x2a5ce
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
jmp 0x2bb81
movzwl 0x1cd0(%rbx), %eax
cmpq $0x1000, %rax           # imm = 0x1000
jae 0x2a7da
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
movq 0x680(%rbx), %rax
movsbl 0x30(%rax), %ecx
movsbl 0x34(%rax), %r8d
movsbl 0x38(%rax), %r9d
movsbl 0x3c(%rax), %r10d
subq $0x8, %rsp
leaq 0xa0a6(%rip), %rdx      # 0x34727
xorl %eax, %eax
pushq %r10
callq 0x1070
popq %rcx
popq %rdx
jmp 0x2a7d3
movq 0x680(%rbx), %rax
vpbroadcastb 0x713d(%rip), %xmm0 # 0x317de
vmovdqa %xmm0, 0x30(%rax)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a6df
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0xa07e(%rip), %rdx      # 0x3474f
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0x2a704
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2bd78
movq 0x680(%rbx), %rcx
movb %al, 0x30(%rcx,%r14)
incq %r14
jmp 0x2a6e2
movzwl 0x1cd0(%rbx), %eax
cmpq $0x1000, %rax           # imm = 0x1000
jae 0x2a7da
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
movq 0x680(%rbx), %rax
movsbl 0x30(%rax), %ecx
movsbl 0x31(%rax), %r8d
movsbl 0x32(%rax), %r9d
movsbl 0x33(%rax), %edx
movq %rdx, (%rsp)
movsbl 0x34(%rax), %edx
movq %rdx, 0x18(%rsp)
movsbl 0x35(%rax), %edx
movq %rdx, 0x20(%rsp)
movsbl 0x36(%rax), %edx
movq %rdx, 0x10(%rsp)
movsbl 0x37(%rax), %edx
movq %rdx, 0x8(%rsp)
movsbl 0x38(%rax), %edx
movq %rdx, 0x38(%rsp)
movsbl 0x39(%rax), %ebp
movsbl 0x3a(%rax), %r13d
movsbl 0x3b(%rax), %r12d
movsbl 0x3c(%rax), %r15d
movsbl 0x3d(%rax), %r14d
movsbl 0x3e(%rax), %r11d
movsbl 0x3f(%rax), %r10d
subq $0x8, %rsp
leaq 0x9fcb(%rip), %rdx      # 0x3476e
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %r14
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
pushq 0x78(%rsp)
pushq 0x50(%rsp)
pushq 0x60(%rsp)
pushq 0x78(%rsp)
pushq 0x78(%rsp)
pushq 0x68(%rsp)
callq 0x1070
addq $0x70, %rsp
addw %ax, 0x1cd0(%rbx)
movq %rbx, %rdi
callq 0x2be59
movq %rbx, %rdi
callq 0x2b345
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b4a1
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a855
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
cmpl $0x20, %ebp
leaq 0xa094(%rip), %rax      # 0x348c2
leaq 0xa09e(%rip), %rcx      # 0x348d3
cmoveq %rax, %rcx
cmpl $0x11, %ebp
leaq 0xa06e(%rip), %rdx      # 0x348b1
cmovneq %rcx, %rdx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
movb $0x0, 0x651(%rbx)
movq 0x680(%rbx), %rax
vmovdqa 0x20(%rax), %xmm0
vpor 0x2970(%rip), %xmm0, %xmm0 # 0x2d1e0
vmovdqa %xmm0, 0x20(%rax)
vpxor %xmm0, %xmm0, %xmm0
vpinsrb $0x1, 0x1ae0(%rbx), %xmm0, %xmm0
vpinsrb $0x2, 0x1b20(%rbx), %xmm0, %xmm0
movq 0x680(%rbx), %rax
vmovd %xmm0, 0x4(%rax)
movq 0x680(%rbx), %rax
movabsq $0xacacac000000ac, %rcx # imm = 0xACACAC000000AC
movq %rcx, 0x8(%rax)
movq 0x680(%rbx), %rax
vpbroadcastb 0x6f1e(%rip), %xmm0 # 0x317dc
vmovdqa %xmm0, 0x60(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0x50(%rax)
movq 0x680(%rbx), %rax
vmovdqa %xmm0, 0x40(%rax)
movq 0x680(%rbx), %rax
vpbroadcastb 0x6ef2(%rip), %xmm0 # 0x317dd
vmovdqa %xmm0, 0x30(%rax)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2a94c
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
movzwl 0x170(%rbx), %eax
incq %rax
tzcntq %rax, %rcx
movzwl 0x180(%rbx), %eax
incq %rax
tzcntq %rax, %r8
leaq 0x9e83(%rip), %rdx      # 0x347ba
xorl %eax, %eax
callq 0x1070
addw 0x1cd0(%rbx), %ax
movw %ax, 0x1cd0(%rbx)
leaq 0x1cd2(%rbx), %r13
leaq 0x170(%rbx), %rcx
movq %rcx, 0x38(%rsp)
pushq $0x10
popq %rcx
xorl %r12d, %r12d
movl %ecx, 0x20(%rsp)
movl %ecx, %r8d
cmpq $0x3, %r12
je 0x2ac53
cmpw $0xfff, %ax             # imm = 0xFFF
ja 0x2a9bc
movzwl %ax, %edi
addq %r13, %rdi
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq (%r12,%r12,2), %rcx
leaq 0x86b9(%rip), %rax      # 0x33050
addq %rax, %rcx
leaq 0x9e4d(%rip), %rdx      # 0x347ee
xorl %eax, %eax
movl %r8d, %ebp
callq 0x1070
movl %ebp, %r8d
addw 0x1cd0(%rbx), %ax
movw %ax, 0x1cd0(%rbx)
movq %r12, %rcx
shlq $0x4, %rcx
movq 0x38(%rsp), %rdx
movzwl (%rdx,%rcx), %ecx
incq %rcx
tzcntq %rcx, %r14
movq 0x668(%rbx,%r12,8), %r15
movl 0x20(%rsp), %ebp
movq %r12, 0x18(%rsp)
testl %r8d, %r8d
jle 0x2abf2
movl %r8d, (%rsp)
cmpl $0x8, %r14d
jne 0x2ab99
movq %rbx, %rdi
pushq $0x20
popq %r12
movl %r12d, %esi
callq 0x1539a
movbel %eax, (%r15)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1539a
movl %eax, %r10d
movbel %eax, 0x4(%r15)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2aab7
bswapl %r10d
movl %r10d, %ecx
shrl $0x18, %ecx
movq %rcx, 0x8(%rsp)
movl %r10d, %r12d
shrl $0x10, %r12d
movl %r10d, %r11d
shrl $0x8, %r11d
leaq (%rax,%r13), %rdi
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
movzbl (%r15), %ecx
movzbl 0x1(%r15), %r8d
movzbl 0x2(%r15), %r9d
movzbl 0x3(%r15), %eax
movq %rax, 0x10(%rsp)
movl $0xff, %eax
andl %eax, %r10d
andl %eax, %r11d
andl %eax, %r12d
subq $0x8, %rsp
leaq 0x9d6a(%rip), %rdx      # 0x347fa
xorl %eax, %eax
pushq 0x10(%rsp)
pushq %r12
pushq %r11
pushq %r10
pushq 0x38(%rsp)
callq 0x1070
addq $0x30, %rsp
addw 0x1cd0(%rbx), %ax
movw %ax, 0x1cd0(%rbx)
cmpl $0x10, 0x20(%rsp)
jne 0x2ab7f
movq %rbx, %rdi
pushq $0x20
popq %r12
movl %r12d, %esi
callq 0x1539a
movbel %eax, 0x8(%r15)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1539a
movl %eax, %r10d
movbel %eax, 0xc(%r15)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2ab7f
bswapl %r10d
movl %r10d, %ecx
shrl $0x18, %ecx
movq %rcx, 0x8(%rsp)
movl %r10d, %r12d
shrl $0x10, %r12d
movl %r10d, %r11d
shrl $0x8, %r11d
leaq (%rax,%r13), %rdi
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
movzbl 0x8(%r15), %ecx
movzbl 0x9(%r15), %r8d
movzbl 0xa(%r15), %r9d
movzbl 0xb(%r15), %eax
movq %rax, 0x10(%rsp)
movl $0xff, %eax
andl %eax, %r10d
andl %eax, %r11d
andl %eax, %r12d
subq $0x8, %rsp
leaq 0x9ca2(%rip), %rdx      # 0x347fa
xorl %eax, %eax
pushq 0x10(%rsp)
pushq %r12
pushq %r11
pushq %r10
pushq 0x38(%rsp)
callq 0x1070
addq $0x30, %rsp
addw 0x1cd0(%rbx), %ax
movw %ax, 0x1cd0(%rbx)
movl (%rsp), %r8d
decl %r8d
movq 0x18(%rsp), %r12
movzwl 0x34(%rbx,%r12,2), %ecx
addq %rcx, %r15
jmp 0x2a9e5
xorl %r12d, %r12d
cmpq %r12, %rbp
je 0x2ab7f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1539a
movl %eax, %ecx
movw %cx, (%r15,%r12,2)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2abed
leaq (%rax,%r13), %rdi
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
movzwl %cx, %ecx
leaq 0x9c37(%rip), %rdx      # 0x3480f
xorl %eax, %eax
callq 0x1070
addw 0x1cd0(%rbx), %ax
movw %ax, 0x1cd0(%rbx)
incq %r12
jmp 0x2ab9c
cmpw $0x1000, %ax            # imm = 0x1000
jae 0x2ac24
movzwl %ax, %edi
addq %r13, %rdi
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x9c71(%rip), %rdx      # 0x34880
xorl %eax, %eax
callq 0x1070
addw 0x1cd0(%rbx), %ax
movw %ax, 0x1cd0(%rbx)
movsbq 0x2a(%rbx), %rcx
xorl %edx, %edx
cmpq $0x3, %rcx
setge %dl
leal 0x8(,%rdx,8), %edx
movl %edx, 0x20(%rsp)
movl $0x10100800, 0x44(%rsp) # imm = 0x10100800
movsbl 0x44(%rsp,%rcx), %r8d
incq %r12
jmp 0x2a96c
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a3ec