// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/edge264_headers.c
// Function: parse_slice_layer_without_partitioning_log
int ADD_VARIANT(parse_slice_layer_without_partitioning)(Edge264Decoder *dec, int non_blocking, void(*free_cb)(void*,int), void *free_arg)
{
	static const char * const slice_type_names[5] = {"P", "B", "I", "SP", "SI"};
	static const char * const disable_deblocking_filter_idc_names[3] = {"enabled", "disabled", "sliced"};
	
	// reserving a slot without locking is fine since workers can only unset busy_tasks
	unsigned avail_tasks;
	while (!(avail_tasks = 0xffff & ~dec->busy_tasks)) {
		if (non_blocking)
			return EWOULDBLOCK;
		pthread_cond_wait(&dec->task_complete, &dec->lock);
	}
	Edge264Task *t = dec->tasks + __builtin_ctz(avail_tasks);
	t->free_cb = free_cb;
	t->free_arg = free_arg;
	t->RefPicList_v[0] = t->RefPicList_v[1] = t->RefPicList_v[2] = t->RefPicList_v[3] =
		(i8x16){-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
	
	// check on view_id
	int non_base_view = 1;
	unsigned same_views = dec->non_base_views;
	Edge264SeqParameterSet *sps = &dec->ssps;
	if (dec->nal_unit_type != 20) {
		non_base_view = 0;
		same_views = ~same_views;
		sps = &dec->sps;
		dec->IdrPicFlag = dec->nal_unit_type == 5;
	}
	
	// first important fields and checks before decoding the slice header
	t->first_mb_in_slice = get_ue32(&dec->_gb, 139263);
	int slice_type = get_ue16(&dec->_gb, 9);
	slice_type = (dec->nal_unit_type == 5 || sps->max_num_ref_frames == 0) ? 2 : slice_type; // enforce condition in 7.4.3
	t->slice_type = (slice_type < 5) ? slice_type : slice_type - 5;
	int pic_parameter_set_id = get_ue16(&dec->_gb, 255);
	log_dec(dec, "  first_mb_in_slice: %u\n"
		"  slice_type: %u # %s%s\n"
		"  pic_parameter_set_id: %u%s\n",
		t->first_mb_in_slice,
		slice_type, slice_type_names[t->slice_type], unsup_if(t->slice_type > 2),
		pic_parameter_set_id, unsup_if(pic_parameter_set_id >= 4));
	if (t->slice_type > 2 || pic_parameter_set_id >= 4)
		return ENOTSUP;
	t->pps = dec->PPS[pic_parameter_set_id];
	if (!sps->DPB_format || !t->pps.num_ref_idx_active[0]) // if SPS or PPS wasn't initialized
		return EBADMSG;
	
	// parse frame_num and detect the start of a new frame (7.4.1.2.4)
	int frame_num = get_uv(&dec->_gb, sps->log2_max_frame_num);
	frame_num = dec->IdrPicFlag ? 0 : frame_num; // enforce condition in 7.4.3
	int FrameNumMask = (1 << sps->log2_max_frame_num) - 1;
	if (dec->currPic >= 0 && (frame_num != (dec->FrameNum & FrameNumMask) ||
		(dec->nal_ref_idc > 0) != (dec->pic_reference_flags >> dec->currPic & 1) ||
		(dec->nal_unit_type == 20) != (dec->non_base_views >> dec->currPic & 1))) {
		finish_frame(dec);
	}
	// the test on frame_num must happen before PrevRefFrameNum to get an up-to-date value
	int PrevRefFrameNum = dec->PrevRefFrameNum[non_base_view];
	dec->FrameNum = PrevRefFrameNum + 1 + ((frame_num - PrevRefFrameNum - 1) & FrameNumMask);
	log_dec(dec, "  frame_num: {bits: %u, absolute: %u}\n",
		sps->log2_max_frame_num, dec->FrameNum);
	
	// check for gaps in frame_num (8.2.5.2)
	int gap = dec->FrameNum - PrevRefFrameNum;
	if (__builtin_expect(gap > 1, 0)) {
		// make enough non-referenced slots by dereferencing frames
		int non_existing = min(gap - 1, sps->max_num_ref_frames - __builtin_popcount(same_views & dec->long_term_flags));
		for (int excess = __builtin_popcount(same_views & dec->reference_flags) - (sps->max_num_ref_frames - non_existing); excess > 0; excess--) {
			int unref = 0, poc = INT_MAX;
			for (unsigned r = same_views & dec->reference_flags & ~dec->long_term_flags; r; r &= r - 1) {
				int i = __builtin_ctz(r);
				if (dec->FrameNums[i] < poc)
					poc = dec->FrameNums[unref = i];
			}
			dec->reference_flags &= ~(1 << unref);
		}
		// make enough non-outputable slots by raising dispTopFieldOrderCnt
		unsigned output_flags = dec->output_flags;
		for (int excess = __builtin_popcount(same_views & (dec->reference_flags | output_flags)) - (sps->num_frame_buffers - non_existing); excess > 0; excess--) {
			int disp = 0, poc = INT_MAX;
			for (unsigned o = same_views & ~dec->reference_flags & output_flags; o; o &= o - 1) {
				int i = __builtin_ctz(o);
				if (dec->FieldOrderCnt[0][i] < poc)
					poc = dec->FieldOrderCnt[0][disp = i];
			}
			output_flags &= ~(1 << disp);
			dec->dispTopFieldOrderCnt = max(dec->dispTopFieldOrderCnt, poc);
		}
		// stop here if we must wait for get_frame to consume and return enough frames
		if (__builtin_popcount(same_views & (dec->reference_flags | dec->output_flags | dec->borrow_flags)) + non_existing > sps->num_frame_buffers)
			return ENOBUFS;
		// wait until enough free slots are undepended
		unsigned unavail;
		while (__builtin_popcount(unavail = same_views & (dec->reference_flags | output_flags | dec->borrow_flags | depended_frames(dec))) + non_existing > sps->num_frame_buffers) {
			if (non_blocking)
				return EWOULDBLOCK;
			pthread_cond_wait(&dec->task_complete, &dec->lock);
		}
		// finally insert the last non-existing frames one by one
		for (unsigned FrameNum = dec->FrameNum - non_existing; FrameNum < dec->FrameNum; FrameNum++) {
			int i = dec->prevPic = __builtin_ctz(same_views & ~unavail);
			unavail |= 1 << i;
			dec->reference_flags |= 1 << i;
			dec->non_base_views = dec->non_base_views & ~(1 << i) | (dec->nal_unit_type == 20) << i;
			dec->FrameNums[i] = dec->PrevRefFrameNum[non_base_view] = FrameNum;
			int PicOrderCnt = 0;
			if (sps->pic_order_cnt_type == 2) {
				PicOrderCnt = FrameNum * 2;
			} else if (sps->num_ref_frames_in_pic_order_cnt_cycle > 0) {
				PicOrderCnt = (FrameNum / sps->num_ref_frames_in_pic_order_cnt_cycle) *
					sps->PicOrderCntDeltas[sps->num_ref_frames_in_pic_order_cnt_cycle] +
					sps->PicOrderCntDeltas[FrameNum % sps->num_ref_frames_in_pic_order_cnt_cycle];
			}
			dec->FieldOrderCnt[0][i] = dec->FieldOrderCnt[1][i] = PicOrderCnt;
			if (dec->frame_buffers[i] == NULL && alloc_frame(dec, i))
				return ENOMEM;
		}
	}
	
	// As long as PAFF/MBAFF are unsupported, this code won't execute (but is still kept).
	t->field_pic_flag = 0;
	t->bottom_field_flag = 0;
	if (!sps->frame_mbs_only_flag) {
		t->field_pic_flag = get_u1(&dec->_gb);
		log_dec(dec, "  field_pic_flag: %u\n", t->field_pic_flag);
		if (t->field_pic_flag) {
			t->bottom_field_flag = get_u1(&dec->_gb);
			log_dec(dec, "  bottom_field_flag: %u\n",
				t->bottom_field_flag);
		}
	}
	t->MbaffFrameFlag = sps->mb_adaptive_frame_field_flag & ~t->field_pic_flag;
	
	// only the previous idr_pic_id is kept to help detect new frames in streams of IDRs
	int idr_pic_id = -1;
	if (dec->IdrPicFlag) {
		idr_pic_id = get_ue32(&dec->_gb, 65535);
		log_dec(dec, "  idr_pic_id: %u\n", idr_pic_id);
	}
	if (dec->currPic >= 0 && idr_pic_id != dec->idr_pic_id)
		finish_frame(dec);
	dec->idr_pic_id = idr_pic_id;
	
	// Compute Top/BottomFieldOrderCnt (8.2.1).
	int TopFieldOrderCnt, BottomFieldOrderCnt;
	if (sps->pic_order_cnt_type == 0) {
		int pic_order_cnt_lsb = get_uv(&dec->_gb, sps->log2_max_pic_order_cnt_lsb);
		int shift = WORD_BIT - sps->log2_max_pic_order_cnt_lsb;
		// finish_frame triggers here only on non-ref to non-ref so prevRefFrameNum cannot change, thus no need to fix FrameNum computed above
		if (dec->currPic >= 0 && pic_order_cnt_lsb != ((unsigned)dec->TopFieldOrderCnt << shift >> shift))
			finish_frame(dec);
		// finish_frame must execute before prevPicOrderCnt to get an up-to-date value
		int prevPicOrderCnt = dec->prevPicOrderCnt[non_base_view];
		int inc = (pic_order_cnt_lsb - prevPicOrderCnt) << shift >> shift;
		BottomFieldOrderCnt = TopFieldOrderCnt = prevPicOrderCnt + inc;
		log_dec(dec, "  pic_order_cnt: {type: 0, bits: %u, absolute: %d",
			sps->log2_max_pic_order_cnt_lsb, TopFieldOrderCnt);
		if (t->pps.bottom_field_pic_order_in_frame_present_flag && !t->field_pic_flag) {
			BottomFieldOrderCnt += get_se32(&dec->_gb, (-1u << 31) + 1, (1u << 31) - 1);
			log_dec(dec, ", bottom: %d", BottomFieldOrderCnt);
		}
		log_dec(dec, "}\n");
	} else if (sps->pic_order_cnt_type == 1) {
		log_dec(dec, "  pic_order_cnt: {type: 1");
		unsigned absFrameNum = dec->FrameNum + (dec->nal_ref_idc != 0) - 1;
		TopFieldOrderCnt = (dec->nal_ref_idc) ? 0 : sps->offset_for_non_ref_pic;
		if (sps->num_ref_frames_in_pic_order_cnt_cycle > 0) {
			TopFieldOrderCnt += (absFrameNum / sps->num_ref_frames_in_pic_order_cnt_cycle) *
				sps->PicOrderCntDeltas[sps->num_ref_frames_in_pic_order_cnt_cycle] +
				sps->PicOrderCntDeltas[absFrameNum % sps->num_ref_frames_in_pic_order_cnt_cycle];
		}
		BottomFieldOrderCnt = TopFieldOrderCnt + sps->offset_for_top_to_bottom_field;
		if (!sps->delta_pic_order_always_zero_flag) {
			int delta_pic_order_cnt0 = get_se32(&dec->_gb, (-1u << 31) + 1, (1u << 31) - 1);
			TopFieldOrderCnt += delta_pic_order_cnt0;
			BottomFieldOrderCnt += delta_pic_order_cnt0;
			log_dec(dec, ", delta0: %d", delta_pic_order_cnt0);
			if (t->pps.bottom_field_pic_order_in_frame_present_flag && !t->field_pic_flag) {
				int delta_pic_order_cnt1 = get_se32(&dec->_gb, (-1u << 31) + 1, (1u << 31) - 1);
				BottomFieldOrderCnt += delta_pic_order_cnt1;
				log_dec(dec, ", delta1: %d", delta_pic_order_cnt1);
			}
		}
		if (dec->currPic >= 0 && TopFieldOrderCnt != dec->TopFieldOrderCnt)
			finish_frame(dec);
		log_dec(dec, (TopFieldOrderCnt == BottomFieldOrderCnt) ?
			", absolute: %d}" : ", absolute: %d, bottom: %d}\n",
			TopFieldOrderCnt, BottomFieldOrderCnt);
	} else {
		TopFieldOrderCnt = BottomFieldOrderCnt = dec->FrameNum * 2 + (dec->nal_ref_idc != 0) - 1;
		log_dec(dec, "  pic_order_cnt: {type: 2, absolute: %d}", TopFieldOrderCnt);
	}
	dec->TopFieldOrderCnt = TopFieldOrderCnt;
	dec->BottomFieldOrderCnt = BottomFieldOrderCnt;
	
	// find and possibly allocate a DPB slot for the upcoming frame
	if (dec->currPic < 0) {
		// reset refs if we jumped from a stream with higher limit
		if (__builtin_popcount(same_views & dec->reference_flags) > sps->max_num_ref_frames)
			dec->reference_flags = dec->long_term_flags = 0;
		// stop here if we must wait for get_frame to consume and return a non-ref frame
		if (__builtin_popcount(same_views & (dec->reference_flags | dec->output_flags | dec->borrow_flags)) >= sps->num_frame_buffers)
			return ENOBUFS;
		// wait until at least one empty slot is undepended
		unsigned unavail;
		while (__builtin_popcount(same_views & (unavail = dec->reference_flags | dec->output_flags | dec->borrow_flags | depended_frames(dec))) >= sps->num_frame_buffers) {
			if (non_blocking)
				return EWOULDBLOCK;
			pthread_cond_wait(&dec->task_complete, &dec->lock);
		}
		dec->currPic = __builtin_ctz(~unavail);
		dec->output_flags |= 1 << dec->currPic;
		dec->non_base_views = dec->non_base_views & ~(1 << dec->currPic) | (dec->nal_unit_type == 20) << dec->currPic;
		dec->frame_flip_bits ^= 1 << dec->currPic;
		dec->remaining_mbs[dec->currPic] = sps->pic_width_in_mbs * sps->pic_height_in_mbs;
		dec->next_deblock_addr[dec->currPic] = 0;
		dec->FrameNums[dec->currPic] = dec->FrameNum;
		dec->FrameIds[dec->currPic] = (dec->prevPic >= 0) ? dec->FrameIds[dec->prevPic] + 1 : 0;
		dec->FieldOrderCnt[0][dec->currPic] = dec->TopFieldOrderCnt;
		dec->FieldOrderCnt[1][dec->currPic] = dec->BottomFieldOrderCnt;
		if (dec->frame_buffers[dec->currPic] == NULL && alloc_frame(dec, dec->currPic))
			return ENOMEM;
	}
	dec->pic_reference_flags = dec->reference_flags & same_views;
	dec->pic_long_term_flags = dec->long_term_flags & same_views;
	dec->pic_LongTermFrameIdx_v[0] = dec->LongTermFrameIdx_v[0];
	dec->pic_LongTermFrameIdx_v[1] = dec->LongTermFrameIdx_v[1];
	log_dec(dec, "  FrameId: %u\n", dec->FrameIds[dec->currPic]);
	
	// P/B slices
	if (t->slice_type < 2) {
		if (t->slice_type == 1) {
			t->direct_spatial_mv_pred_flag = get_u1(&dec->_gb);
			log_dec(dec, "  direct_spatial_mv_pred_flag: %u\n",
				t->direct_spatial_mv_pred_flag);
		}
		
		// num_ref_idx_active_override_flag
		int lim = 16 << t->field_pic_flag; // MVC limit is not enforced since MVC detection is too cumbersome
		if (get_u1(&dec->_gb)) {
			for (int l = 0; l <= t->slice_type; l++)
				t->pps.num_ref_idx_active[l] = get_ue16(&dec->_gb, lim - 1) + 1;
			log_dec(dec, "  num_ref_idx_active: {override_flag: 1");
		} else {
			t->pps.num_ref_idx_active[0] = min(t->pps.num_ref_idx_active[0], lim);
			t->pps.num_ref_idx_active[1] = min(t->pps.num_ref_idx_active[1], lim);
			log_dec(dec, "  num_ref_idx_active: {override_flag: 0");
		}
		log_dec(dec, t->slice_type ? ", l0: %u, l1: %u}\n" : ", l0: %u}\n",
			t->pps.num_ref_idx_active[0], t->pps.num_ref_idx_active[1]);
		
		parse_ref_pic_list_modification(dec, sps, t);
		parse_pred_weight_table(dec, sps, t);
	}
	
	if (dec->nal_ref_idc)
		parse_dec_ref_pic_marking(dec, sps);
	
	t->cabac_init_idc = 0;
	if (t->pps.entropy_coding_mode_flag && t->slice_type != 2) {
		t->cabac_init_idc = 1 + get_ue16(&dec->_gb, 2);
		log_dec(dec, "  cabac_init_idc: %u\n", t->cabac_init_idc - 1);
	}
	t->QP[0] = t->pps.QPprime_Y + get_se16(&dec->_gb, -t->pps.QPprime_Y, 51 - t->pps.QPprime_Y); // FIXME QpBdOffset
	log_dec(dec, "  slice_qp_delta: %d\n", t->QP[0] - t->pps.QPprime_Y);
	
	if (t->pps.deblocking_filter_control_present_flag) {
		t->disable_deblocking_filter_idc = get_ue16(&dec->_gb, 2);
		log_dec(dec, "  disable_deblocking_filter_idc: %u # %s\n",
			t->disable_deblocking_filter_idc, disable_deblocking_filter_idc_names[t->disable_deblocking_filter_idc]);
		if (t->disable_deblocking_filter_idc != 1) {
			t->FilterOffsetA = get_se16(&dec->_gb, -6, 6) * 2;
			t->FilterOffsetB = get_se16(&dec->_gb, -6, 6) * 2;
			log_dec(dec, "  slice_alpha_c0_offset: %d\n"
				"  slice_beta_offset: %d\n", t->FilterOffsetA, t->FilterOffsetB);
		}
	} else {
		t->disable_deblocking_filter_idc = 0;
		t->FilterOffsetA = 0;
		t->FilterOffsetB = 0;
	}
	
	// update output flags now that we know if mmco5 happened
	if (dec->IdrPicFlag) {
		int max_poc = INT_MIN;
		for (unsigned o = dec->output_flags & same_views & ~(1 << dec->currPic); o; o &= o - 1)
			max_poc = max(max_poc, dec->FieldOrderCnt[0][__builtin_ctz(o)]);
		dec->dispTopFieldOrderCnt = (unsigned)-1 << 16;
		for (unsigned o = dec->output_flags & same_views & ~(1 << dec->currPic); o; o &= o - 1) {
			int i = __builtin_ctz(o);
			dec->FieldOrderCnt[0][i] -= max_poc + (1 << 16);
			dec->FieldOrderCnt[1][i] -= max_poc + (1 << 16);
		}
	}
	if (!dec->nal_ref_idc)
		dec->dispTopFieldOrderCnt = dec->TopFieldOrderCnt; // make all frames with lower POCs ready for output
	
	#ifdef LOGS
		log_dec(dec, "  FrameBuffer:\n");
		unsigned reference_flags = dec->pic_reference_flags | dec->reference_flags & ~same_views;
		unsigned long_term_flags = dec->pic_long_term_flags | dec->long_term_flags & ~same_views;
		for (int i = 0; i < 32 - __builtin_clzg(reference_flags | dec->output_flags, 32); i++) {
			log_dec(dec, "    - {id: %u", dec->FrameIds[i]);
			if (reference_flags & 1 << i)
				log_dec(dec, long_term_flags & 1 << i ? ", lref: %u" : ", sref: %u", long_term_flags & 1 << i ? dec->LongTermFrameIdx[i] : dec->FrameNums[i]);
			if (dec->output_flags & 1 << i)
				log_dec(dec, ", poc: %d", minw(dec->FieldOrderCnt[0][i], dec->FieldOrderCnt[1][i]));
			if (dec->non_base_views)
				log_dec(dec, ", view: %u", dec->non_base_views >> i & 1);
			log_dec(dec, "}\n");
		}
	#endif
	
	// prepare the task and signal it
	initialize_task(dec, sps, t);
	int task_id = t - dec->tasks;
	dec->busy_tasks |= 1 << task_id;
	dec->pending_tasks |= 1 << task_id;
	dec->task_dependencies[task_id] = refs_to_mask(t);
	dec->ready_tasks |= ((dec->task_dependencies[task_id] & ~ready_frames(dec)) == 0) << task_id;
	dec->taskPics[task_id] = dec->currPic;
	if (!dec->n_threads)
		log_dec(dec, t->pps.entropy_coding_mode_flag ? "  macroblocks_cabac:\n" : "  macroblocks_cavlc:\n");
	if (print_dec(dec))
		return ENOTSUP;
	if (!dec->n_threads)
		return (intptr_t)dec->worker_loop(dec);
	pthread_cond_signal(&dec->task_ready);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x1648(%rdi), %eax
cmpw $-0x1, %ax
je 0x2362c
notl %eax
tzcntl %eax, %eax
movq %rax, 0x78(%rsp)
imulq $0x650, %rax, %rdx      # imm = 0x650
leaq (%rbx,%rdx), %rax
addq $0x17a0, %rax           # imm = 0x17A0
movq %r15, 0x160(%rax)
movq %rax, %r15
movq %r14, 0x168(%rax)
vpcmpeqd %ymm0, %ymm0, %ymm0
vmovdqu %ymm0, 0x1a0(%rax)
vmovdqu %ymm0, 0x1c0(%rax)
movl 0x78(%rbx), %ecx
movb 0x22(%rbx), %al
cmpb $0x14, %al
movq %rdx, 0x38(%rsp)
jne 0x23342
movl %ecx, 0x1c(%rsp)
leaq 0x940(%rbx), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %r12d
jmp 0x2335d
notl %ecx
movl %ecx, 0x1c(%rsp)
leaq 0x530(%rbx), %rcx
movq %rcx, 0x10(%rsp)
cmpb $0x5, %al
sete 0x23(%rbx)
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0x21fff, %esi          # imm = 0x21FFF
vzeroupper
callq 0x25872
movq %r15, 0x20(%rsp)
movl %eax, 0x48(%r15)
movq %rbx, %rdi
movl $0x9, %esi
callq 0x25872
movb $0x2, %cl
movl $0x2, %r15d
cmpb $0x5, 0x22(%rbx)
je 0x233ab
movq 0x10(%rsp), %rdx
cmpb $0x0, 0xf(%rdx)
je 0x233ab
leal -0x5(%rax), %ecx
cmpl $0x5, %eax
movzbl %cl, %ecx
cmovll %eax, %ecx
movl %eax, %r15d
movq 0x20(%rsp), %r13
movb %cl, 0x20(%r13)
movq %rbx, %rdi
movl $0xff, %esi
callq 0x25872
movl %eax, %r14d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23446
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movl 0x48(%r13), %ecx
movsbq 0x20(%r13), %rax
leaq 0x14860(%rip), %rdx     # 0x37c58
movslq (%rdx,%rax,4), %r9
addq %rdx, %r9
cmpq $0x3, %rax
leaq 0x175d5(%rip), %rax     # 0x3a9df
leaq 0x142e9(%rip), %r10     # 0x376fa
movq %r10, %r11
cmovlq %rax, %r11
cmpl $0x4, %r14d
cmovlq %rax, %r10
subq $0x8, %rsp
leaq 0x1651f(%rip), %rdx     # 0x3994a
movl %r15d, %r8d
xorl %eax, %eax
pushq %r10
pushq %r14
pushq %r11
callq 0x1070
addq $0x20, %rsp
addw %ax, 0x7cb0(%rbx)
cmpb $0x3, 0x20(%r13)
setge %al
cmpl $0x4, %r14d
setge %cl
orb %al, %cl
movl $0x5f, %eax
jne 0x23635
leaq 0x220(%r13), %r15
movslq %r14d, %rax
imulq $0x1f0, %rax, %rax      # imm = 0x1F0
leaq (%rbx,%rax), %rsi
addq $0xd50, %rsi            # imm = 0xD50
movl $0x1f0, %edx            # imm = 0x1F0
movq %r15, %rdi
callq 0x10c0
movl $0x4a, %eax
movq 0x10(%rsp), %rcx
cmpq $0x0, (%rcx)
je 0x23635
movq %r15, 0x70(%rsp)
cmpb $0x0, 0x222(%r13)
je 0x23635
movq 0x10(%rsp), %r14
movsbl 0xa(%r14), %esi
movq %rbx, %rdi
callq 0x18ad7
movq %rbx, %r13
xorl %ebx, %ebx
cmpb $0x0, 0x23(%r13)
cmovel %eax, %ebx
movb 0xa(%r14), %al
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
shlxl %eax, %ecx, %r15d
notl %r15d
movsbl 0x24(%r13), %eax
testl %eax, %eax
js 0x23527
movl 0x38(%r13), %ecx
andl %r15d, %ecx
cmpl %ecx, %ebx
jne 0x2351f
movl 0x70(%r13), %ecx
cmpb $0x0, 0x21(%r13)
setle %dl
btl %eax, %ecx
sbbb $0x0, %dl
je 0x2351f
shrxl %eax, 0x78(%r13), %eax
cmpb $0x14, 0x22(%r13)
setne %cl
xorb %al, %cl
testb $0x1, %cl
jne 0x23527
movq %r13, %rdi
callq 0x258da
movl 0x3c(%r13,%r12,4), %r14d
movl %r14d, %eax
notl %eax
addl %eax, %ebx
andl %r15d, %ebx
leal (%r14,%rbx), %r8d
incl %r8d
movl %r8d, 0x38(%r13)
movzwl 0x7cb0(%r13), %eax
cmpq $0x2541, %rax           # imm = 0x2541
movq %r13, 0x8(%rsp)
ja 0x2358e
leaq (%rax,%r13), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movq 0x10(%rsp), %rax
movsbl 0xa(%rax), %ecx
leaq 0x1641d(%rip), %rdx     # 0x39998
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%r13)
movl 0x38(%r13), %r8d
subl %r14d, %r8d
cmpl $0x2, %r8d
jge 0x2555e
movq 0x20(%rsp), %r14
movw $0x0, 0x21(%r14)
movq 0x10(%rsp), %rax
cmpb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rbx
je 0x23675
movb 0x21(%r14), %al
notb %al
movq 0x10(%rsp), %rcx
andb 0x11(%rcx), %al
movb %al, 0x23(%r14)
cmpb $0x0, 0x23(%rbx)
je 0x2371c
movq %rbx, %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x25872
movl %eax, %r14d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23722
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x163d8(%rip), %rdx     # 0x399ee
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x23722
movl $0xb, %eax
testl %ebp, %ebp
je 0x2364a
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0x1618(%rbx), %r12
leaq 0x1590(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x1050
movzwl 0x1648(%rbx), %eax
cmpw $-0x1, %ax
je 0x23658
jmp 0x232da
movq %rbx, %rdi
callq 0x25dac
movb %al, 0x21(%r14)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x236c2
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
leaq 0x1630f(%rip), %rdx     # 0x399bf
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movb 0x21(%r14), %al
testb %al, %al
je 0x235bb
movq %rbx, %rdi
callq 0x25dac
movb %al, 0x22(%r14)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x235bb
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
leaq 0x162cc(%rip), %rdx     # 0x399d5
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x235bb
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpb $0x0, 0x24(%rbx)
js 0x23736
cmpl 0x44(%rbx), %r14d
je 0x23736
movq %rbx, %rdi
callq 0x258da
movl %r14d, 0x44(%rbx)
movq 0x10(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x1, %eax
je 0x2387f
testl %eax, %eax
jne 0x23982
movq 0x10(%rsp), %r15
movsbl 0xc(%r15), %esi
movq %rbx, %rdi
callq 0x18ad7
movl %eax, %r14d
movsbl 0xc(%r15), %ecx
movl $0x20, %eax
movq %rbx, %r13
movl $0x20, %ebx
subl %ecx, %ebx
cmpb $0x0, 0x24(%r13)
js 0x23799
subl %ebx, %eax
bzhil %eax, 0x50(%r13), %eax
cmpl %eax, %r14d
je 0x23799
movq %r13, %rdi
callq 0x258da
movl 0x48(%r13,%r12,4), %eax
subl %eax, %r14d
shlxl %ebx, %r14d, %ecx
sarxl %ebx, %ecx, %r15d
addl %eax, %r15d
movzwl 0x7cb0(%r13), %eax
cmpq $0x2541, %rax           # imm = 0x2541
movq %r13, %rbx
ja 0x237fc
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movq 0x10(%rsp), %rax
movsbl 0xc(%rax), %ecx
leaq 0x1621c(%rip), %rdx     # 0x39a00
movl %r15d, %r8d
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
movq 0x20(%rsp), %rcx
cmpb $0x0, 0x221(%rcx)
je 0x239d4
cmpb $0x0, 0x21(%rcx)
movl %r15d, %r12d
jne 0x239d7
movq %rbx, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x25dec
movl %eax, %r12d
addl %r15d, %r12d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23a0b
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x161d0(%rip), %rdx     # 0x39a32
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
jmp 0x239d7
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x238c0
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rcx, %rsi
leaq 0x16196(%rip), %rdx     # 0x39a3f
xorl %eax, %eax
callq 0x1070
movl %eax, %ecx
addw 0x7cb0(%rbx), %cx
movw %cx, 0x7cb0(%rbx)
xorl %r15d, %r15d
xorl %eax, %eax
cmpb $0x0, 0x21(%rbx)
setne %dl
jne 0x238d8
movq 0x10(%rsp), %rsi
movswl 0x1c(%rsi), %r15d
movq 0x10(%rsp), %r8
movzbl 0xe(%r8), %esi
testl %esi, %esi
je 0x2390a
movl 0x38(%rbx), %edi
movb %dl, %al
addl %edi, %eax
decl %eax
movl %esi, %edx
movswl 0x28(%r8,%rdx,2), %edi
xorl %edx, %edx
divl %esi
imull %edi, %eax
movswl 0x28(%r8,%rdx,2), %edx
addl %edx, %r15d
addl %eax, %r15d
movswl 0x1e(%r8), %r12d
addl %r15d, %r12d
cmpb $0x0, 0xd(%r8)
je 0x2487d
cmpb $0x0, 0x24(%rbx)
js 0x23938
cmpl 0x50(%rbx), %r15d
je 0x23938
movq %rbx, %rdi
callq 0x258da
movzwl 0x7cb0(%rbx), %ecx
movzwl %cx, %eax
cmpl $0x2541, %eax           # imm = 0x2541
ja 0x23a0b
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
cmpl %r12d, %r15d
leaq 0x16144(%rip), %rax     # 0x39aa9
leaq 0x16107(%rip), %rdx     # 0x39a73
cmoveq %rax, %rdx
movl %r15d, %ecx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x1070
jmp 0x23a04
movl 0x38(%rbx), %eax
xorl %ecx, %ecx
cmpb $0x0, 0x21(%rbx)
setne %cl
leal (%rcx,%rax,2), %r15d
decl %r15d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x239cf
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x160d0(%rip), %rdx     # 0x39a90
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1070
movl %r15d, %r12d
jmp 0x23a04
movl %r15d, %r12d
jmp 0x23a0b
movl %r15d, %r12d
movzwl %ax, %eax
cmpl $0x2541, %eax           # imm = 0x2541
ja 0x23a0b
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x170f4(%rip), %rdx     # 0x3aaf1
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movl %r15d, 0x50(%rbx)
movl %r12d, 0x54(%rbx)
cmpb $0x0, 0x24(%rbx)
movq 0x20(%rsp), %r15
js 0x23b64
vmovq 0x5c(%rbx), %xmm0
movl 0x1c(%rsp), %eax
vpbroadcastd %eax, %xmm1
vpand %xmm1, %xmm0, %xmm0
vmovq %xmm0, 0x70(%rbx)
vmovdqu 0x390(%rbx), %ymm0
vmovdqu %ymm0, 0x3b0(%rbx)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23a92
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movsbq 0x24(%rbx), %rax
movl 0xfc(%rbx,%rax,4), %ecx
leaq 0x16038(%rip), %rdx     # 0x39ab9
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbx)
cmpb $0x1, 0x20(%r15)
jg 0x24553
jne 0x23aeb
movq %rbx, %rdi
vzeroupper
callq 0x25dac
movb %al, 0x24(%r15)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x23aeb
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
leaq 0x15feb(%rip), %rdx     # 0x39ac8
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movb 0x21(%r15), %al
movl $0x10, %ecx
shlxl %eax, %ecx, %ebp
movq %rbx, %rdi
vzeroupper
callq 0x25dac
testl %eax, %eax
je 0x23c45
cmpb $0x0, 0x20(%r15)
movq %rbx, %r14
js 0x23b40
decl %ebp
movq $-0x1, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x25872
incb %al
movb %al, 0x223(%r15,%rbx)
movsbq 0x20(%r15), %rax
incq %rbx
cmpq %rax, %rbx
jl 0x23b1f
movzwl 0x7cb0(%r14), %eax
cmpl $0x2542, %eax           # imm = 0x2542
movq 0x10(%rsp), %rbp
jae 0x23d17
leaq 0x15f8c(%rip), %rdx     # 0x39aeb
jmp 0x23c8e
movl 0x5c(%rbx), %esi
movl %esi, %eax
movl 0x1c(%rsp), %edi
andl %edi, %eax
popcntl %eax, %eax
movq 0x10(%rsp), %rcx
movsbl 0xf(%rcx), %ecx
cmpl %ecx, %eax
jle 0x23b8a
movq $0x0, 0x5c(%rbx)
xorl %esi, %esi
movl 0x64(%rbx), %ecx
movl 0x68(%rbx), %edx
movl %ecx, %eax
orl %esi, %eax
orl %edx, %eax
andl %edi, %eax
xorl %r8d, %r8d
popcntl %eax, %r8d
movq 0x10(%rsp), %rax
movsbl 0x13(%rax), %edi
movl $0x69, %eax
cmpl %edi, %r8d
jge 0x23635
leaq 0x1618(%rbx), %r14
leaq 0x1590(%rbx), %r15
movl 0x1c(%rsp), %r12d
vmovdqa 0x1760(%rbx), %xmm0
vmovdqa 0x1780(%rbx), %xmm1
vpor 0x1750(%rbx), %xmm0, %xmm0
vpternlogd $0xfe, 0x1770(%rbx), %xmm1, %xmm0
orl %esi, %edx
vpsrldq $0x8, %xmm0, %xmm1      # xmm1 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
vorpd %xmm1, %xmm0, %xmm0
vpsrlq $0x20, %xmm0, %xmm1
vpor %xmm1, %xmm0, %xmm0
vmovd %xmm0, %eax
orl %ecx, %edx
orl %eax, %edx
movl %edx, %eax
andl %r12d, %eax
popcntl %eax, %eax
movsbl %dil, %esi
cmpl %esi, %eax
jl 0x24959
testl %ebp, %ebp
jne 0x25752
movq %r14, %rdi
movq %r15, %rsi
callq 0x1050
movl 0x5c(%rbx), %esi
movl 0x64(%rbx), %ecx
movl 0x68(%rbx), %edx
movq 0x10(%rsp), %rax
movb 0x13(%rax), %dil
jmp 0x23bca
movsbl 0x222(%r15), %eax
cmpl %ebp, %eax
cmovgel %ebp, %eax
movb %al, 0x222(%r15)
movsbl 0x223(%r15), %eax
cmpl %ebp, %eax
cmovll %eax, %ebp
movb %bpl, 0x223(%r15)
movzwl 0x7cb0(%rbx), %eax
cmpl $0x2541, %eax           # imm = 0x2541
movq %rbx, %r14
movq 0x10(%rsp), %rbp
ja 0x23d17
leaq 0x15e85(%rip), %rdx     # 0x39b13
movzwl %ax, %ecx
movq 0x8(%rsp), %r14
leaq (%r14,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ebx           # imm = 0x2542
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%r14), %ax
movw %ax, 0x7cb0(%r14)
movzwl %ax, %eax
cmpl $0x2541, %eax           # imm = 0x2541
ja 0x23d17
leaq (%r14,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
subl %eax, %ebx
cmpb $0x0, 0x20(%r15)
movzwl %bx, %esi
leaq 0x15e61(%rip), %rax     # 0x39b4e
leaq 0x15e47(%rip), %rdx     # 0x39b3b
cmoveq %rax, %rdx
movsbl 0x222(%r15), %ecx
movsbl 0x223(%r15), %r8d
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%r14)
movq 0x38(%rsp), %rax
addq %r14, %rax
addq $0x1940, %rax           # imm = 0x1940
movq %rax, 0x48(%rsp)
leaq 0x7c(%r14), %r13
leaq 0x3d0(%r14), %rcx
leaq 0x50(%r14), %rax
leaq 0x38(%r14), %rdx
cmpb $0x0, 0x20(%r15)
cmoveq %r13, %rcx
cmovneq %rax, %rdx
movl (%rdx), %edx
movl $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
xorl %eax, %eax
cmpb $0x0, 0x23(%r14)
movq %r14, %rbx
jne 0x23e1f
movl 0x70(%rbx), %esi
testl %esi, %esi
je 0x23e1f
movl 0x74(%rbx), %edi
xorl %eax, %eax
movl $0x1, %r8d
xorl %r9d, %r9d
movq 0x8(%rsp), %r12
movl $0x7fffffff, %r11d      # imm = 0x7FFFFFFF
movl %esi, %r10d
movl %r11d, %ebx
tzcntl %r10d, %r14d
movl (%rcx,%r14,4), %r11d
subl %edx, %r11d
movl %r11d, %ebp
negl %ebp
leal 0x10000(%r11), %r15d
testl %r11d, %r11d
cmovlel %ebp, %r15d
movsbl 0x390(%r12,%r14), %r11d
addl $0x20000, %r11d         # imm = 0x20000
btl %r14d, %edi
cmovael %r15d, %r11d
cmpl %ebx, %r11d
cmovgel %ebx, %r11d
cmovll %r14d, %r9d
blsrl %r10d, %r10d
jne 0x23d94
movq 0x48(%rsp), %r10
movb %r9b, (%r10,%rax)
incq %rax
sarl $0x10, %r11d
movslq %r11d, %r10
incl 0x58(%rsp,%r10,4)
shlxl %r9d, %r8d, %r10d
movl %esi, %r11d
btcl %r9d, %r11d
cmpl %esi, %r10d
movl %r11d, %esi
jne 0x23d8b
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r15
movq 0x10(%rsp), %rbp
cmpb $0x14, 0x22(%rbx)
jne 0x23e34
movb 0x25(%rbx), %cl
movl %eax, %edx
incl %eax
movq 0x48(%rsp), %rsi
movb %cl, (%rsi,%rdx)
testl %eax, %eax
jle 0x23e81
movslq 0x58(%rsp), %rcx
movslq 0x5c(%rsp), %rdx
movq %rdx, %rsi
addq %rcx, %rsi
movl %eax, %eax
xorl %edi, %edi
cmpq %rsi, %rdi
movl $0x0, %r8d
cmovll %ecx, %r8d
negl %r8d
cmpq %rcx, %rdi
cmovll %edx, %r8d
addl %edi, %r8d
movb 0x1a0(%r15,%rdi), %r9b
movslq %r8d, %r8
movb %r9b, 0x1c0(%r15,%r8)
incq %rdi
cmpq %rdi, %rax
jne 0x23e4c
movb 0x1a1(%r15), %al
testb %al, %al
js 0x23eaa
movb 0x1a0(%r15), %cl
cmpb 0x1c0(%r15), %cl
jne 0x23eaa
movb %al, 0x1c0(%r15)
movb %cl, 0x1c1(%r15)
cmpb $0x0, 0x20(%r15)
js 0x24260
leaq 0x7cb2(%rbx), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %r14
xorl %ebp, %ebp
movq %r13, 0x80(%rsp)
cmpb $0x0, 0x21(%r15)
movl 0x38(%rbx), %eax
leal 0x1(%rax,%rax), %ecx
cmovel %eax, %ecx
movl %ecx, 0x54(%rsp)
movq %rbx, %rdi
callq 0x25dac
testl %eax, %eax
je 0x24120
movq %r14, 0x68(%rsp)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23f30
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x16b14(%rip), %rdx     # 0x3aa34
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x25872
cmpl $0x3, %eax
je 0x240e5
movl %eax, %r14d
movl $0x1, %eax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %r12
movq $0x0, 0x30(%rsp)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x25872
movl %eax, %r15d
movzwl 0x7cb0(%rbx), %eax
movq %rbx, %r13
movl %r15d, %ebx
notl %ebx
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23fe3
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
xorl %r8d, %r8d
cmpl $0x2, %r14d
leaq 0x16ac6(%rip), %rcx     # 0x3aa6e
leaq 0x16aba(%rip), %rax     # 0x3aa69
cmoveq %rax, %rcx
leaq 0x16aaa(%rip), %rax     # 0x3aa64
cmovlq %rax, %rcx
setne %r8b
addl %r15d, %r8d
testb $0x3, %r14b
cmovel %ebx, %r8d
leaq 0x16a84(%rip), %rdx     # 0x3aa58
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%r13)
movsbl 0x25(%r13), %eax
cmpl $0x1, %r14d
jg 0x2404b
incl %r15d
testl %r14d, %r14d
cmovel %ebx, %r15d
movl 0x54(%rsp), %edi
addl %r15d, %edi
movl 0x74(%r13), %ecx
andnl 0x70(%r13), %ecx, %ecx
movq %r13, %rbx
movl %edi, 0x54(%rsp)
je 0x2407d
movq 0x10(%rsp), %rax
movb 0xa(%rax), %al
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shlxl %eax, %edx, %edx
notl %edx
movq 0x20(%rsp), %r15
movq 0x80(%rsp), %r13
tzcntl %ecx, %eax
movl (%r13,%rax,4), %esi
xorl %edi, %esi
testl %edx, %esi
je 0x24082
blsrl %ecx, %ecx
jne 0x24033
jmp 0x24082
cmpl $0x2, %r14d
jne 0x24078
movq 0x8(%rsp), %rbx
movl 0x74(%rbx), %ecx
andl 0x70(%rbx), %ecx
je 0x2407d
tzcntl %ecx, %eax
movsbl 0x390(%rbx,%rax), %edx
cmpl %edx, %r15d
je 0x2407d
blsrl %ecx, %ecx
jne 0x2405e
jmp 0x2407d
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r15
movq %r12, %rcx
movq 0x28(%rsp), %rdx
movl %eax, %esi
movl %esi, %edi
movb (%rcx), %sil
movb %dil, (%rcx)
movsbq 0x222(%r15,%rbp), %rdi
cmpq %rdi, %rdx
jge 0x240b0
movsbl %sil, %edi
incq %rdx
incq %rcx
cmpl %edi, %eax
jne 0x2408c
movq %rbx, %rdi
movl $0x5, %esi
callq 0x25872
cmpl $0x3, %eax
je 0x240e5
movl %eax, %r14d
movq 0x30(%rsp), %rcx
leaq 0x1(%rcx), %rax
incq 0x28(%rsp)
incq %r12
cmpq $0x1f, %rcx
movq %rax, 0x30(%rsp)
jb 0x23f61
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2542, %rax           # imm = 0x2542
movq 0x68(%rsp), %r14
jae 0x24120
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x168be(%rip), %rdx     # 0x3a9d0
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
leaq 0x1(%rbp), %rcx
movsbq 0x20(%r15), %rax
addq $0x20, %r14
cmpq %rax, %rbp
movq %rcx, %rbp
jl 0x23ed0
testb %al, %al
movq 0x10(%rsp), %rbp
js 0x24260
movzwl 0x7cb0(%rbx), %eax
leaq 0x1691f(%rip), %r15     # 0x3aa73
leaq 0x16187(%rip), %rbx     # 0x3a2e2
leaq 0x16865(%rip), %r14     # 0x3a9c7
xorl %r12d, %r12d
movzwl %ax, %ecx
cmpl $0x2541, %ecx           # imm = 0x2541
ja 0x241a2
movq %rcx, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %eax           # imm = 0x2542
subl %ecx, %eax
movzwl %ax, %esi
movq %r15, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1070
movq 0x8(%rsp), %rcx
addw 0x7cb0(%rcx), %ax
movw %ax, 0x7cb0(%rcx)
movq 0x20(%rsp), %rcx
movb 0x222(%rcx,%r12), %cl
testb %cl, %cl
jle 0x2422d
xorl %r13d, %r13d
movzwl %ax, %edx
cmpl $0x2541, %edx           # imm = 0x2541
ja 0x24221
movsbq %cl, %rax
movq 0x48(%rsp), %rcx
movsbq (%rcx,%r13), %rcx
movq %rdx, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %esi           # imm = 0x2542
subl %edx, %esi
movzwl %si, %esi
decq %rax
cmpq %rax, %r13
movq %r14, %rdx
cmovlq %rbx, %rdx
movq 0x8(%rsp), %rbp
movl 0xfc(%rbp,%rcx,4), %ecx
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
movq 0x10(%rsp), %rbp
movq 0x20(%rsp), %rcx
movb 0x222(%rcx,%r12), %cl
incq %r13
movsbq %cl, %rdx
cmpq %rdx, %r13
jl 0x241b6
leaq 0x1(%r12), %rdx
movq 0x20(%rsp), %rcx
movsbq 0x20(%rcx), %rcx
addq $0x20, 0x48(%rsp)
cmpq %rcx, %r12
movq %rdx, %r12
jl 0x24165
testb %cl, %cl
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r15
je 0x254fe
movb 0x225(%r15), %al
cmpb $0x1, %al
jne 0x24553
movq %rbx, %rdi
movl $0x7, %esi
callq 0x25872
movb %al, 0x25(%r15)
cmpb $0x0, 0x8(%rbp)
je 0x24297
movq %rbx, %rdi
movl $0x7, %esi
callq 0x25872
movb %al, 0x26(%r15)
cmpb $0x0, 0x20(%r15)
js 0x24553
leaq 0x7cb2(%rbx), %rax
movq %rax, 0x30(%rsp)
movzwl 0x7cb0(%rbx), %eax
addq %rbx, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x40(%rsp)
movzwl %ax, %edi
cmpl $0x2541, %edi           # imm = 0x2541
ja 0x24307
movl $0x2542, %eax           # imm = 0x2542
subl %edi, %eax
addq 0x30(%rsp), %rdi
movzwl %ax, %esi
leaq 0x16798(%rip), %rdx     # 0x3aa85
movq 0x28(%rsp), %rcx
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
movq 0x28(%rsp), %rcx
cmpb $0x0, 0x222(%r15,%rcx)
jle 0x24531
movq 0x28(%rsp), %r13
shlq $0x5, %r13
movq 0x40(%rsp), %r14
movq %rbx, %rdi
callq 0x25dac
testl %eax, %eax
je 0x24375
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x25dec
movq 0x38(%rsp), %rcx
movq %rbp, %r12
movq %rcx, %rbp
movw %ax, 0x1bb0(%rcx,%r14,2)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x25dec
movq %rbp, %rcx
movq %r12, %rbp
jmp 0x24393
movb 0x25(%r15), %al
movl $0x1, %ecx
shlxl %eax, %ecx, %eax
movq 0x38(%rsp), %rcx
movw %ax, 0x1bb0(%rcx,%r14,2)
xorl %eax, %eax
movb %al, 0x1d30(%rcx,%r14)
cmpb $0x0, 0x8(%rbp)
je 0x2442f
movq %rbx, %rdi
callq 0x25dac
testl %eax, %eax
je 0x2442f
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x25dec
movq 0x38(%rsp), %rcx
movq %rbp, %r12
movq %rcx, %rbp
movw %ax, 0x1c30(%rcx,%r14,2)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x25dec
movb %al, 0x1d70(%rbp,%r14)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x25dec
movw %ax, 0x1cb0(%rbp,%r14,2)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x25dec
movb %al, 0x1db0(%rbp,%r14)
movq %r12, %rbp
movsbl %al, %r10d
jmp 0x24467
movb 0x26(%r15), %al
movl $0x1, %ecx
shlxl %eax, %ecx, %eax
movq 0x38(%rsp), %rcx
movw %ax, 0x1c30(%rcx,%r14,2)
xorl %r10d, %r10d
movb %r10b, 0x1d70(%rcx,%r14)
movw %ax, 0x1cb0(%rcx,%r14,2)
movb %r10b, 0x1db0(%rcx,%r14)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24514
movq 0x30(%rsp), %rcx
leaq (%rcx,%rax), %rdi
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
cmpb $0x0, 0x8(%rbp)
leaq 0x16608(%rip), %rdx     # 0x3aa9e
leaq 0x1663e(%rip), %rax     # 0x3aadb
cmoveq %rax, %rdx
movq 0x38(%rsp), %rbx
movswl 0x1bb0(%rbx,%r14,2), %ecx
movsbl 0x25(%r15), %r8d
movsbl 0x1d30(%rbx,%r14), %r9d
movswl 0x1c30(%rbx,%r14,2), %r11d
movq 0x20(%rsp), %rax
movsbl 0x26(%rax), %r15d
movsbl 0x1d70(%rbx,%r14), %ebp
movswl 0x1cb0(%rbx,%r14,2), %ebx
xorl %eax, %eax
pushq %r10
pushq %r15
pushq %rbx
movq 0x20(%rsp), %rbx
pushq %rbp
movq 0x30(%rsp), %rbp
pushq %r15
movq 0x48(%rsp), %r15
pushq %r11
callq 0x1070
addq $0x30, %rsp
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
incq %r14
movq 0x28(%rsp), %rcx
movsbq 0x222(%r15,%rcx), %rcx
addq %r13, %rcx
cmpq %rcx, %r14
jl 0x24329
movq 0x28(%rsp), %rsi
leaq 0x1(%rsi), %rcx
movsbq 0x20(%r15), %rdx
addq $0x20, 0x40(%rsp)
cmpq %rdx, %rsi
movq %rcx, 0x28(%rsp)
jl 0x242cc
cmpb $0x0, 0x21(%rbx)
je 0x24a11
leaq 0x3b0(%rbx), %r14
movq %rbx, %r15
movb 0x23(%rbx), %bl
movq %r15, %rdi
vzeroupper
callq 0x25dac
movl %eax, %ebp
testb %bl, %bl
je 0x24606
movb 0x24(%r15), %al
movl $0x1, %ecx
shlxl %eax, %ecx, %eax
movl %eax, 0x70(%r15)
movq %r15, %rdi
callq 0x25dac
movzbl 0x24(%r15), %ecx
shlxl %ecx, %eax, %eax
movl %eax, 0x74(%r15)
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, (%r14)
movzwl 0x7cb0(%r15), %edx
cmpq $0x2541, %rdx           # imm = 0x2541
movq %r15, %rbx
movq 0x20(%rsp), %r15
ja 0x24a11
leaq (%rbx,%rdx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subl %edx, %esi
movzwl %si, %esi
shrxl %ecx, %eax, %r8d
leaq 0x1660d(%rip), %rdx     # 0x3abfb
movl %ebp, %ecx
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x24a11
testl %ebp, %ebp
movq %r15, %rbx
je 0x24859
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x2464a
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x16602(%rip), %rdx     # 0x3ac3e
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x25872
testl %eax, %eax
je 0x24859
movl %eax, %ebp
leaq 0x7cb2(%rbx), %rax
movq %rax, 0x30(%rsp)
movl $0x20, %eax
subl $0x1, %eax
jb 0x24859
movl %eax, 0x38(%rsp)
movsbl 0x24(%rbx), %r13d
xorl %r12d, %r12d
movl $0xa, %eax
btl %ebp, %eax
jae 0x24707
movq 0x8(%rsp), %rax
movl 0x38(%rax), %ebx
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x25872
movl %eax, %r15d
notl %r15d
addl %ebx, %r15d
movq 0x8(%rsp), %r8
movl 0x70(%r8), %eax
movl 0x74(%r8), %ecx
andnl %eax, %ecx, %edx
je 0x2470a
movl $0x1, %r9d
movl %r13d, %esi
tzcntl %edx, %r13d
movl 0x7c(%r8,%r13,4), %edi
cmpl %r15d, %edi
cmovel %r13d, %esi
cmpl $0x1, %ebp
jne 0x246fb
cmpl %r15d, %edi
jne 0x246fb
btcl %r13d, %eax
movl %eax, 0x70(%r8)
btrl %r13d, %ecx
movl %ecx, 0x74(%r8)
jmp 0x246fe
movl %esi, %r13d
blsrl %edx, %edx
jne 0x246cb
jmp 0x24710
xorl %r15d, %r15d
movl $0x1, %r9d
shlxl %ebp, %r9d, %eax
testb $0x5c, %al
je 0x247aa
movl %eax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movsbl 0xf(%rax), %esi
xorl %eax, %eax
cmpl $0x4, %ebp
setne %al
subl %eax, %esi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25872
movl %eax, %r12d
movl 0x74(%rbx), %eax
movl %eax, %ecx
testl %eax, %eax
movl $0x1, %r8d
je 0x2478b
cmpl $0x4, %ebp
sete %sil
tzcntl %ecx, %edx
movsbl (%r14,%rdx), %edi
cmpl %edi, %r12d
setl %dil
je 0x24771
andb %dil, %sil
je 0x24784
shlxl %edx, %r8d, %esi
movq 0x8(%rsp), %rdi
xorl %esi, 0x70(%rdi)
btcl %edx, %eax
movl %eax, 0x74(%rdi)
blsrl %ecx, %ecx
jne 0x24753
testb $0x48, 0x28(%rsp)
je 0x247aa
movslq %r13d, %rax
movq 0x8(%rsp), %rcx
movb %r12b, 0x3b0(%rcx,%rax)
shlxl %eax, %r8d, %eax
orl %eax, 0x74(%rcx)
cmpl $0x5, %ebp
movq 0x8(%rsp), %rbx
jne 0x247f1
movb $0x1, 0x23(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x70(%rbx)
movsbq 0x24(%rbx), %rax
movl %ecx, 0x7c(%rbx,%rax,4)
movl %ecx, 0x74(%rbx)
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, (%r14)
movl 0x50(%rbx), %ecx
movl 0x54(%rbx), %edx
cmpl %edx, %ecx
movl %edx, %esi
cmovsl %ecx, %esi
subl %esi, %ecx
movl %ecx, 0x3d0(%rbx,%rax,4)
subl %esi, %edx
movl %edx, 0x450(%rbx,%rax,4)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x2483b
movq %rax, %rdi
addq 0x30(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movslq %ebp, %rax
leaq 0x14f04(%rip), %rcx     # 0x39720
movslq -0x4(%rcx,%rax,4), %rdx
addq %rcx, %rdx
movl %r15d, %ecx
movl %r12d, %r8d
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq %rbx, %rdi
movl $0x6, %esi
vzeroupper
callq 0x25872
movl %eax, %ebp
testl %eax, %eax
movl 0x38(%rsp), %eax
jne 0x24672
movl 0x70(%rbx), %eax
xorl %ecx, %ecx
popcntl %eax, %ecx
movq 0x10(%rsp), %rdx
movsbl 0xf(%rdx), %edx
cmpl %edx, %ecx
jge 0x249d4
movq 0x20(%rsp), %r15
jmp 0x24a08
movq %rbx, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x25dec
movl %eax, %r14d
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x248d6
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rcx, %rsi
leaq 0x1519d(%rip), %rdx     # 0x39a59
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
movl %eax, %ecx
addw 0x7cb0(%rbx), %cx
movw %cx, 0x7cb0(%rbx)
addl %r14d, %r15d
addl %r14d, %r12d
movq 0x20(%rsp), %rax
cmpb $0x0, 0x221(%rax)
je 0x2391d
cmpb $0x0, 0x21(%rax)
jne 0x2391d
movq %rbx, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x25dec
addl %eax, %r12d
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x2391d
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rcx, %rsi
leaq 0x1512b(%rip), %rdx     # 0x39a66
movl %eax, %ecx
xorl %eax, %eax
callq 0x1070
movl %eax, %ecx
addw 0x7cb0(%rbx), %cx
movw %cx, 0x7cb0(%rbx)
jmp 0x2391d
notl %edx
tzcntl %edx, %esi
movb %sil, 0x24(%rbx)
movl $0x1, %eax
shlxl %esi, %eax, %eax
btsl %esi, %ecx
movl %ecx, 0x64(%rbx)
movl 0x78(%rbx), %ecx
btrl %esi, %ecx
xorl %edx, %edx
cmpb $0x14, 0x22(%rbx)
sete %dl
shlxl %esi, %edx, %edx
orl %ecx, %edx
movl %edx, 0x78(%rbx)
xorl %eax, 0x6c(%rbx)
movq 0x10(%rsp), %rcx
movzwl 0x4(%rcx), %eax
movswl 0x6(%rcx), %ecx
imull %eax, %ecx
movl %ecx, 0x1650(%rbx,%rsi,4)
movl $0x0, 0x16d0(%rbx,%rsi,4)
movl 0x38(%rbx), %eax
movl %eax, 0x7c(%rbx,%rsi,4)
movsbq 0x25(%rbx), %rax
testq %rax, %rax
js 0x25511
movl 0xfc(%rbx,%rax,4), %eax
incl %eax
jmp 0x25513
movl 0x74(%rbx), %edx
xorl %ecx, %ecx
cmpl %eax, %edx
movq 0x20(%rsp), %r15
je 0x24a05
xorl %eax, %edx
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
tzcntl %edx, %edi
movl 0x7c(%rbx,%rdi,4), %r8d
cmpl %r8d, %esi
cmovgel %r8d, %esi
cmovgl %edi, %ecx
blsrl %edx, %edx
jne 0x249eb
btcl %ecx, %eax
movb 0x24(%rbx), %cl
btsl %ecx, %eax
movl %eax, 0x70(%rbx)
movb $0x0, 0x2c(%r15)
cmpb $0x0, 0x220(%r15)
je 0x24a7c
cmpb $0x2, 0x20(%r15)
je 0x24a7c
movq %rbx, %rdi
movl $0x2, %esi
vzeroupper
callq 0x25872
incb %al
movb %al, 0x2c(%r15)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x24a7c
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
decl %ecx
leaq 0x150eb(%rip), %rdx     # 0x39b59
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movsbl 0x226(%r15), %ebx
movl $0x33, %edx
subl %ebx, %edx
movl %ebx, %esi
negl %esi
movq 0x8(%rsp), %rdi
vzeroupper
callq 0x25dec
movl %eax, %ecx
addb %bl, %cl
movq 0x8(%rsp), %rbx
movb %cl, 0x50(%r15)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24af4
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movsbl %cl, %ecx
movsbl 0x226(%r15), %eax
subl %eax, %ecx
leaq 0x15090(%rip), %rdx     # 0x39b6f
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
cmpb $0x0, 0x228(%r15)
movl 0x1c(%rsp), %r14d
je 0x24bf5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x25872
movl %eax, %edx
movb %dl, 0x27(%r15)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24b71
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movsbl %dl, %ecx
movsbq %dl, %rax
leaq 0x13122(%rip), %rdx     # 0x37c6c
movslq (%rdx,%rax,4), %r8
addq %rdx, %r8
leaq 0x1502d(%rip), %rdx     # 0x39b85
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
movb 0x27(%r15), %dl
cmpb $0x1, %dl
je 0x24c01
movq %rbx, %rdi
movl $0xfffffffa, %esi       # imm = 0xFFFFFFFA
movl $0x6, %edx
callq 0x25dec
addb %al, %al
movb %al, 0x28(%r15)
movq %rbx, %rdi
movl $0xfffffffa, %esi       # imm = 0xFFFFFFFA
movl $0x6, %edx
callq 0x25dec
movl %eax, %edx
addb %dl, %dl
movb %dl, 0x29(%r15)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24c01
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movsbl 0x28(%r15), %ecx
movsbl %dl, %r8d
leaq 0x14fd1(%rip), %rdx     # 0x39baf
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
jmp 0x24c01
movw $0x0, 0x27(%r15)
movb $0x0, 0x29(%r15)
cmpb $0x0, 0x23(%rbx)
je 0x24c68
movl 0x64(%rbx), %ecx
movb 0x24(%rbx), %dl
btrl %edx, %ecx
andl %r14d, %ecx
je 0x24c61
movl $0x80000000, %edx       # imm = 0x80000000
movl %ecx, %esi
movl %edx, %edi
tzcntl %esi, %edx
movl 0x3d0(%rbx,%rdx,4), %edx
cmpl %edx, %edi
cmovgl %edi, %edx
blsrl %esi, %esi
jne 0x24c1c
movl $0xffff0000, 0x58(%rbx) # imm = 0xFFFF0000
testl %ecx, %ecx
je 0x24c68
addl $0x10000, %edx          # imm = 0x10000
tzcntl %ecx, %esi
subl %edx, 0x3d0(%rbx,%rsi,4)
subl %edx, 0x450(%rbx,%rsi,4)
blsrl %ecx, %ecx
jne 0x24c46
jmp 0x24c68
movl $0xffff0000, 0x58(%rbx) # imm = 0xFFFF0000
cmpb $0x0, 0x21(%rbx)
jne 0x24c74
movl 0x50(%rbx), %ecx
movl %ecx, 0x58(%rbx)
movzwl %ax, %ecx
cmpl $0x2541, %ecx           # imm = 0x2541
ja 0x24cb0
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %eax           # imm = 0x2542
subl %ecx, %eax
movzwl %ax, %esi
leaq 0x14f49(%rip), %rdx     # 0x39be4
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
andnl 0x5c(%rbx), %r14d, %ebp
orl 0x70(%rbx), %ebp
movl 0x64(%rbx), %ecx
orl %ebp, %ecx
je 0x24ea5
movq 0x8(%rsp), %rcx
andnl 0x60(%rcx), %r14d, %r14d
orl 0x74(%rcx), %r14d
leaq 0x7cb2(%rcx), %r15
xorl %ebx, %ebx
movzwl %ax, %ecx
cmpl $0x2541, %ecx           # imm = 0x2541
ja 0x24d24
movq %rcx, %rdi
addq %r15, %rdi
movl $0x2542, %eax           # imm = 0x2542
subl %ecx, %eax
movzwl %ax, %esi
movq 0x8(%rsp), %r12
movl 0xfc(%r12,%rbx,4), %ecx
leaq 0x14ee9(%rip), %rdx     # 0x39bf4
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%r12), %ax
movw %ax, 0x7cb0(%r12)
movl $0x1, %ecx
shlxl %ebx, %ecx, %r13d
btl %ebx, %ebp
jae 0x24d98
movzwl %ax, %esi
cmpl $0x2541, %esi           # imm = 0x2541
ja 0x24d98
leaq 0x14ebd(%rip), %rdx     # 0x39c02
testl %r14d, %r13d
leaq 0x14ebe(%rip), %rax     # 0x39c0d
cmoveq %rax, %rdx
je 0x24d65
movq 0x8(%rsp), %r12
movsbl 0x390(%r12,%rbx), %ecx
jmp 0x24d6f
movq 0x8(%rsp), %r12
movl 0x7c(%r12,%rbx,4), %ecx
movq %rsi, %rdi
addq %r15, %rdi
movl $0x2542, %eax           # imm = 0x2542
subl %esi, %eax
movzwl %ax, %esi
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%r12), %ax
movw %ax, 0x7cb0(%r12)
movq 0x8(%rsp), %rcx
testl %r13d, 0x64(%rcx)
je 0x24df8
movzwl %ax, %ecx
cmpl $0x2541, %ecx           # imm = 0x2541
ja 0x24df8
movq %rcx, %rdi
addq %r15, %rdi
movl $0x2542, %eax           # imm = 0x2542
subl %ecx, %eax
movzwl %ax, %esi
movq 0x8(%rsp), %r12
movl 0x3d0(%r12,%rbx,4), %eax
movl 0x450(%r12,%rbx,4), %ecx
cmpl %ecx, %eax
cmovsl %eax, %ecx
leaq 0x14e39(%rip), %rdx     # 0x39c18
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%r12), %ax
movw %ax, 0x7cb0(%r12)
movq 0x8(%rsp), %rcx
movl 0x78(%rcx), %ecx
testl %ecx, %ecx
je 0x24e48
movzwl %ax, %edx
cmpl $0x2541, %edx           # imm = 0x2541
ja 0x24e84
movq %rdx, %rdi
addq %r15, %rdi
movl $0x2542, %eax           # imm = 0x2542
subl %edx, %eax
movzwl %ax, %esi
shrxl %ebx, %ecx, %ecx
andl $0x1, %ecx
leaq 0x14df4(%rip), %rdx     # 0x39c22
xorl %eax, %eax
callq 0x1070
movq 0x8(%rsp), %rcx
addw 0x7cb0(%rcx), %ax
movw %ax, 0x7cb0(%rcx)
movzwl %ax, %ecx
cmpl $0x2541, %ecx           # imm = 0x2541
ja 0x24e84
movq %rcx, %rdi
addq %r15, %rdi
movl $0x2542, %eax           # imm = 0x2542
subl %ecx, %eax
movzwl %ax, %esi
leaq 0x15c87(%rip), %rdx     # 0x3aaf1
xorl %eax, %eax
callq 0x1070
movq 0x8(%rsp), %rcx
addw 0x7cb0(%rcx), %ax
movw %ax, 0x7cb0(%rcx)
incq %rbx
movq 0x8(%rsp), %rcx
movl 0x64(%rcx), %ecx
orl %ebp, %ecx
lzcntl %ecx, %ecx
movl $0x20, %edx
subl %ecx, %edx
cmpq %rdx, %rbx
jb 0x24cdc
movq 0x8(%rsp), %rbx
vmovups (%rbx), %ymm0
movq 0x20(%rsp), %r15
vmovups %ymm0, (%r15)
cmpb $0x0, 0x20(%rbx)
je 0x24ede
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq $-0x2, %rdi
xorl %edx, %edx
vzeroupper
callq 0x1150
movq %rax, 0x8(%r15)
addq $0x2, %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %r12
movb 0x8(%r12), %al
movb %al, 0x2a(%r15)
movb 0x12(%r12), %al
movb %al, 0x2b(%r15)
movzwl 0x4(%r12), %eax
movw %ax, 0x30(%r15)
movzwl 0x6(%r12), %eax
movw %ax, 0x32(%r15)
cmpb $0x0, 0x22b(%r15)
je 0x25013
vmovdqa 0x230(%r15), %xmm0
vmovdqa 0x240(%r15), %xmm1
vmovdqa 0x250(%r15), %xmm2
vmovdqa 0x260(%r15), %xmm3
vptestnmb %xmm0, %xmm0, %k1
vmovdqu8 0x230(%r12), %xmm0 {%k1}
vmovdqa %xmm0, 0x230(%r15)
vptestnmb %xmm1, %xmm1, %k1
vmovdqu8 0x230(%r12), %xmm1 {%k1}
vmovdqa %xmm1, 0x240(%r15)
vptestnmb %xmm2, %xmm2, %k1
vmovdqu8 0x230(%r12), %xmm2 {%k1}
vmovdqa %xmm2, 0x250(%r15)
vptestnmb %xmm3, %xmm3, %k1
vmovdqu8 0x260(%r12), %xmm3 {%k1}
vmovdqa %xmm3, 0x260(%r15)
vmovdqa 0x270(%r15), %xmm0
vptestnmb %xmm0, %xmm0, %k1
vmovdqu8 0x260(%r12), %xmm0 {%k1}
vmovdqa %xmm0, 0x270(%r15)
vmovdqa 0x280(%r15), %xmm0
vptestnmb %xmm0, %xmm0, %k1
vmovdqu8 0x260(%r12), %xmm0 {%k1}
vmovdqa %xmm0, 0x280(%r15)
movl $0x290, %eax            # imm = 0x290
leaq (%r15,%rax), %rcx
addq %r12, %rax
xorl %edx, %edx
vmovdqa (%rcx), %xmm0
movl %edx, %esi
andl $0x7, %esi
shll $0x4, %esi
vptestnmb %xmm0, %xmm0, %k1
vmovdqu8 (%rax,%rsi), %xmm0 {%k1}
vmovdqa %xmm0, (%rcx)
incq %rdx
addq $0x10, %rcx
cmpq $0x18, %rdx
jne 0x24fe7
jmp 0x2505f
leaq 0x230(%r15), %rax
vmovdqu 0x230(%r12), %ymm0
vmovdqu 0x250(%r12), %ymm1
vmovdqu 0x270(%r12), %ymm2
vmovdqu %ymm2, 0x40(%rax)
vmovdqu %ymm1, 0x20(%rax)
vmovdqu %ymm0, (%rax)
movl $0x290, %esi            # imm = 0x290
leaq (%r15,%rsi), %rdi
addq %r12, %rsi
movl $0x180, %edx            # imm = 0x180
vzeroupper
callq 0x10c0
movq %rbx, %rsi
movl 0x24(%rbx), %ebx
movl 0x6c(%rsi), %eax
btl %ebx, %eax
setb 0x2e(%r15)
movl 0x512(%rsi), %eax
movl %eax, %ecx
shrl $0x10, %ecx
movw %cx, 0x38(%r15)
movl %eax, 0x34(%r15)
movq 0x2c(%rsi), %rax
movq %rax, 0x3c(%r15)
movsbq %bl, %rax
movl 0x48(%r15), %ecx
movb $-0x1, %dl
cmpl %ecx, 0x16d0(%rsi,%rax,4)
jne 0x250a9
xorl %edx, %edx
cmpb $0x1, 0x21(%rsi)
sbbl %edx, %edx
orb %bl, %dl
movb %dl, 0x2d(%r15)
cmpl %ecx, 0x16d0(%rsi,%rax,4)
je 0x250c2
movl $0x80000000, %edx       # imm = 0x80000000
cmpb $0x2, 0x27(%r15)
jne 0x250c4
movl %ecx, %edx
movl %edx, 0x44(%r15)
movq 0x8(%rsp), %r14
movl 0x60(%r14), %ecx
movl %ecx, 0x4c(%r15)
movq 0x188(%r14,%rax,8), %rax
movq %rax, 0x58(%r15)
movb 0x1(%r12), %al
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
shlxl %eax, %ecx, %eax
notl %eax
vpbroadcastw %eax, %xmm0
vmovdqa %xmm0, 0x170(%r15)
movb 0x2(%r12), %al
shlxl %eax, %ecx, %eax
notl %eax
vpbroadcastw %eax, %xmm0
vmovdqa %xmm0, 0x190(%r15)
vmovdqa %xmm0, 0x180(%r15)
movb 0x20(%r15), %bpl
cmpb $0x1, %bpl
jg 0x252b1
leaq 0x188(%r14), %rsi
leaq 0x60(%r15), %rdi
movl $0x100, %edx            # imm = 0x100
vzeroupper
callq 0x10c0
cmpb $0x1, %bpl
jne 0x252b1
cmpb $0x2, 0x225(%r15)
je 0x2516a
cmpb $0x0, 0x24(%r15)
jne 0x252b1
movl 0x50(%r14), %eax
movl 0x54(%r14), %ecx
cmpl %ecx, %eax
cmovsl %eax, %ecx
vmovdqa 0x3d0(%r14), %xmm0
vpbroadcastd %ecx, %xmm1
vmovdqa 0x450(%r14), %xmm2
vpsubd %xmm2, %xmm0, %xmm3
vblendvps %xmm3, %xmm0, %xmm2, %xmm0
vpsubd %xmm0, %xmm1, %xmm0
vmovdqa 0x3e0(%r14), %xmm2
vmovdqa 0x460(%r14), %xmm3
vpsubd %xmm3, %xmm2, %xmm4
vblendvps %xmm4, %xmm2, %xmm3, %xmm2
vpsubd %xmm2, %xmm1, %xmm2
vpackssdw %xmm2, %xmm0, %xmm0
vmovdqa %xmm0, 0x1e0(%r15)
vmovdqa 0x3f0(%r14), %xmm0
vmovdqa 0x400(%r14), %xmm2
vmovdqa 0x470(%r14), %xmm3
vmovdqa 0x480(%r14), %xmm4
vpsubd %xmm3, %xmm0, %xmm5
vblendvps %xmm5, %xmm0, %xmm3, %xmm0
vpsubd %xmm0, %xmm1, %xmm0
vpsubd %xmm4, %xmm2, %xmm3
vblendvps %xmm3, %xmm2, %xmm4, %xmm2
vpsubd %xmm2, %xmm1, %xmm2
vpackssdw %xmm2, %xmm0, %xmm0
vmovdqa %xmm0, 0x1f0(%r15)
vmovdqa 0x410(%r14), %xmm0
vmovdqa 0x420(%r14), %xmm2
vmovdqa 0x490(%r14), %xmm3
vmovdqa 0x4a0(%r14), %xmm4
vpsubd %xmm3, %xmm0, %xmm5
vblendvps %xmm5, %xmm0, %xmm3, %xmm0
vpsubd %xmm0, %xmm1, %xmm0
vpsubd %xmm4, %xmm2, %xmm3
vblendvps %xmm3, %xmm2, %xmm4, %xmm2
vpsubd %xmm2, %xmm1, %xmm2
vpackssdw %xmm2, %xmm0, %xmm0
vmovdqa %xmm0, 0x200(%r15)
vmovdqa 0x430(%r14), %xmm0
vmovdqa 0x440(%r14), %xmm2
vmovdqa 0x4b0(%r14), %xmm3
vmovdqa 0x4c0(%r14), %xmm4
vpsubd %xmm3, %xmm0, %xmm5
vblendvps %xmm5, %xmm0, %xmm3, %xmm0
vpsubd %xmm0, %xmm1, %xmm0
vpsubd %xmm4, %xmm2, %xmm3
vblendvps %xmm3, %xmm2, %xmm4, %xmm2
vpsubd %xmm2, %xmm1, %xmm1
vpackssdw %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, 0x210(%r15)
movl $0x1, %eax
movq 0x78(%rsp), %rsi
shlxl %esi, %eax, %eax
vmovq 0x1648(%r14), %xmm0
vpbroadcastw %eax, %xmm1
vpor %xmm1, %xmm0, %xmm0
vmovd %xmm0, 0x1648(%r14)
vpbroadcastb 0x1245f(%rip), %xmm0 # 0x37744
vpaddb 0x1a0(%r15), %xmm0, %xmm1
vpaddb 0x1c0(%r15), %xmm0, %xmm0
vpmovzxbw %xmm1, %xmm2    # xmm2 = xmm1[0],zero,xmm1[1],zero,xmm1[2],zero,xmm1[3],zero,xmm1[4],zero,xmm1[5],zero,xmm1[6],zero,xmm1[7],zero
vpsllw $0x7, %xmm2, %xmm2
vpxor %xmm3, %xmm3, %xmm3
vpunpckhbw %xmm3, %xmm1, %xmm1 # xmm1 = xmm1[8],xmm3[8],xmm1[9],xmm3[9],xmm1[10],xmm3[10],xmm1[11],xmm3[11],xmm1[12],xmm3[12],xmm1[13],xmm3[13],xmm1[14],xmm3[14],xmm1[15],xmm3[15]
vpsllw $0x7, %xmm1, %xmm1
vpmovzxbw %xmm0, %xmm4    # xmm4 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
vpsllw $0x7, %xmm4, %xmm4
vpunpckhbw %xmm3, %xmm0, %xmm0 # xmm0 = xmm0[8],xmm3[8],xmm0[9],xmm3[9],xmm0[10],xmm3[10],xmm0[11],xmm3[11],xmm0[12],xmm3[12],xmm0[13],xmm3[13],xmm0[14],xmm3[14],xmm0[15],xmm3[15]
vpsllw $0x7, %xmm0, %xmm0
vpunpcklwd %xmm2, %xmm3, %xmm5 # xmm5 = xmm3[0],xmm2[0],xmm3[1],xmm2[1],xmm3[2],xmm2[2],xmm3[3],xmm2[3]
vcvtps2dq %xmm5, %xmm5
vpunpckhwd %xmm2, %xmm3, %xmm2 # xmm2 = xmm3[4],xmm2[4],xmm3[5],xmm2[5],xmm3[6],xmm2[6],xmm3[7],xmm2[7]
vcvtps2dq %xmm2, %xmm2
vpor %xmm5, %xmm2, %xmm2
vpunpcklwd %xmm1, %xmm3, %xmm5 # xmm5 = xmm3[0],xmm1[0],xmm3[1],xmm1[1],xmm3[2],xmm1[2],xmm3[3],xmm1[3]
vcvtps2dq %xmm5, %xmm5
vpunpckhwd %xmm1, %xmm3, %xmm1 # xmm1 = xmm3[4],xmm1[4],xmm3[5],xmm1[5],xmm3[6],xmm1[6],xmm3[7],xmm1[7]
vcvtps2dq %xmm1, %xmm1
vpternlogd $0xfe, %xmm5, %xmm2, %xmm1
vpunpcklwd %xmm4, %xmm3, %xmm2 # xmm2 = xmm3[0],xmm4[0],xmm3[1],xmm4[1],xmm3[2],xmm4[2],xmm3[3],xmm4[3]
vcvtps2dq %xmm2, %xmm2
vpunpckhwd %xmm4, %xmm3, %xmm4 # xmm4 = xmm3[4],xmm4[4],xmm3[5],xmm4[5],xmm3[6],xmm4[6],xmm3[7],xmm4[7]
vcvtps2dq %xmm4, %xmm4
vpternlogd $0xfe, %xmm2, %xmm1, %xmm4
vpunpcklwd %xmm0, %xmm3, %xmm1 # xmm1 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3]
vcvtps2dq %xmm1, %xmm1
vpunpckhwd %xmm0, %xmm3, %xmm0 # xmm0 = xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
vcvtps2dq %xmm0, %xmm0
vpternlogd $0xfe, %xmm1, %xmm4, %xmm0
vpsrldq $0x8, %xmm0, %xmm1      # xmm1 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
vorpd %xmm1, %xmm0, %xmm0
vpsrlq $0x20, %xmm0, %xmm1
vpor %xmm1, %xmm0, %xmm0
vmovd %xmm0, 0x1750(%r14,%rsi,4)
vpbroadcastd 0x11fa1(%rip), %xmm1 # 0x37340
vpcmpeqd 0x16d0(%r14), %xmm1, %xmm2
vpcmpeqd 0x16e0(%r14), %xmm1, %xmm3
vmovd %xmm0, %eax
vpackssdw %xmm3, %xmm2, %xmm0
vpcmpeqd 0x16f0(%r14), %xmm1, %xmm2
vpcmpeqd 0x1700(%r14), %xmm1, %xmm3
vpackssdw %xmm3, %xmm2, %xmm2
vpcmpeqd 0x1710(%r14), %xmm1, %xmm3
vpcmpeqd 0x1720(%r14), %xmm1, %xmm4
vpackssdw %xmm4, %xmm3, %xmm3
vpcmpeqd 0x1730(%r14), %xmm1, %xmm4
vpcmpeqd 0x1740(%r14), %xmm1, %xmm1
vpackssdw %xmm1, %xmm4, %xmm1
vpacksswb %xmm2, %xmm0, %xmm0
vpmovmskb %xmm0, %ecx
vpacksswb %xmm1, %xmm3, %xmm0
vpmovmskb %xmm0, %edx
shll $0x10, %edx
orl %ecx, %edx
xorl %ecx, %ecx
andnl %eax, %edx, %eax
sete %cl
shlxl %esi, %ecx, %eax
orw %ax, 0x164c(%r14)
movb %bl, 0x1790(%r14,%rsi)
cmpb $0x0, 0x20(%r14)
movzwl 0x7cb0(%r14), %eax
movq %r14, %rbx
jne 0x2548d
movzwl %ax, %eax
cmpl $0x2542, %eax           # imm = 0x2542
jae 0x254dd
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movq 0x70(%rsp), %rax
cmpb $0x0, (%rax)
leaq 0x147d2(%rip), %rax     # 0x39c43
leaq 0x147b5(%rip), %rdx     # 0x39c2d
cmoveq %rax, %rdx
xorl %eax, %eax
vzeroupper
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw $0x0, 0x7cb0(%rbx)
movzwl %ax, %ecx
movl $0x5f, %eax
cmpl $0x2541, %ecx           # imm = 0x2541
ja 0x23635
leaq 0x7cb2(%rbx), %rdi
movq 0x7ca8(%rbx), %rsi
vzeroupper
callq *0x7ca0(%rbx)
cmpb $0x0, 0x20(%rbx)
je 0x254f0
addq $0x15b8, %rbx           # imm = 0x15B8
movq %rbx, %rdi
callq 0x10a0
xorl %eax, %eax
jmp 0x23635
movw $0x0, 0x7cb0(%rbx)
movl $0x5f, %eax
jmp 0x23635
movq %rbx, %rdi
callq *0x180(%rbx)
jmp 0x23635
movb 0x224(%r15), %al
movb %al, 0x225(%r15)
jmp 0x24267
xorl %eax, %eax
movq 0x20(%rsp), %r15
movl %eax, 0xfc(%rbx,%rsi,4)
movl 0x50(%rbx), %eax
movl %eax, 0x3d0(%rbx,%rsi,4)
movl 0x54(%rbx), %eax
movl %eax, 0x450(%rbx,%rsi,4)
cmpq $0x0, 0x188(%rbx,%rsi,8)
jne 0x23a22
movq %rbx, %rdi
callq 0x25940
movl %eax, %ecx
movl $0xc, %eax
testl %ecx, %ecx
jne 0x23635
jmp 0x23a22
decl %r8d
movq 0x10(%rsp), %rax
movsbl 0xf(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x5c(%rax), %ecx
movl 0x60(%rax), %edx
movl %edx, %eax
movl 0x1c(%rsp), %edi
andl %edi, %eax
popcntl %eax, %eax
movl %esi, %r9d
subl %eax, %r9d
cmpl %r9d, %r8d
cmovll %r8d, %r9d
movl %ecx, %eax
andl %edi, %eax
popcntl %eax, %eax
subl %esi, %eax
movl %r9d, 0x28(%rsp)
addl %r9d, %eax
jle 0x255ed
andnl 0x1c(%rsp), %edx, %edx
movq 0x8(%rsp), %r11
movl %edx, %edi
andl %ecx, %edi
je 0x255da
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %esi, %esi
tzcntl %edi, %r9d
movl 0x7c(%r11,%r9,4), %r10d
cmpl %r8d, %r10d
cmovll %r10d, %r8d
cmovll %r9d, %esi
blsrl %edi, %edi
jne 0x255bc
jmp 0x255dc
xorl %esi, %esi
btrl %esi, %ecx
leal -0x1(%rax), %esi
cmpl $0x1, %eax
movl %esi, %eax
jg 0x255ae
movl %ecx, 0x5c(%r11)
movq 0x8(%rsp), %rax
movl 0x64(%rax), %r13d
movl %ecx, %eax
orl %r13d, %eax
movl %eax, %edx
andl 0x1c(%rsp), %edx
xorl %r8d, %r8d
popcntl %edx, %r8d
movq 0x10(%rsp), %rdx
movb 0x13(%rdx), %dl
movsbl %dl, %r9d
movl 0x28(%rsp), %esi
movl %esi, %edi
movl %r9d, 0x30(%rsp)
subl %r9d, %edi
addl %r8d, %edi
testl %edi, %edi
jle 0x2569a
andnl 0x1c(%rsp), %ecx, %r9d
movq 0x8(%rsp), %rsi
movl 0x58(%rsi), %r8d
movq 0x8(%rsp), %rsi
movl %r9d, %ebx
andl %r13d, %ebx
je 0x25671
movl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
xorl %r11d, %r11d
tzcntl %ebx, %r14d
movl 0x3d0(%rsi,%r14,4), %r15d
cmpl %r10d, %r15d
cmovll %r15d, %r10d
cmovll %r14d, %r11d
blsrl %ebx, %ebx
jne 0x25650
jmp 0x2567a
xorl %r11d, %r11d
movl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
btrl %r11d, %r13d
cmpl %r10d, %r8d
cmovlel %r10d, %r8d
leal -0x1(%rdi), %r10d
cmpl $0x1, %edi
movl %r10d, %edi
jg 0x2563f
movq 0x8(%rsp), %rsi
movl %r8d, 0x58(%rsi)
movq 0x8(%rsp), %r9
movl 0x68(%r9), %edi
orl %edi, %eax
andl 0x1c(%rsp), %eax
xorl %r8d, %r8d
popcntl %eax, %r8d
addl 0x28(%rsp), %r8d
movl $0x69, %eax
cmpl 0x30(%rsp), %r8d
jg 0x23635
leaq 0x1618(%r9), %r14
leaq 0x1590(%r9), %r15
orl %r13d, %ecx
vmovdqa 0x1760(%r9), %xmm0
vmovdqa 0x1780(%r9), %xmm1
vpor 0x1750(%r9), %xmm0, %xmm0
vpternlogd $0xfe, 0x1770(%r9), %xmm1, %xmm0
orl %edi, %ecx
vpsrldq $0x8, %xmm0, %xmm1      # xmm1 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
vorpd %xmm1, %xmm0, %xmm0
vpsrlq $0x20, %xmm0, %xmm1
vpor %xmm1, %xmm0, %xmm0
vmovd %xmm0, %ebx
orl %ecx, %ebx
andl 0x1c(%rsp), %ebx
xorl %eax, %eax
popcntl %ebx, %eax
addl 0x28(%rsp), %eax
movsbl %dl, %ecx
cmpl %ecx, %eax
jle 0x2575c
testl %ebp, %ebp
jne 0x25752
movq %r14, %rdi
movq %r15, %rsi
callq 0x1050
movq 0x8(%rsp), %r9
movl 0x5c(%r9), %ecx
movl 0x68(%r9), %edi
movq 0x10(%rsp), %rax
movb 0x13(%rax), %dl
jmp 0x256d4
movl $0xb, %eax
jmp 0x23635
movq 0x8(%rsp), %rax
movl 0x38(%rax), %ecx
movl %ecx, %r15d
subl 0x28(%rsp), %r15d
cmpl %ecx, %r15d
jae 0x2359b
leal (%rcx,%rcx), %r9d
movl 0x28(%rsp), %eax
addl %eax, %eax
subl %eax, %r9d
movl $0x1, %r10d
movq 0x8(%rsp), %r13
andnl 0x1c(%rsp), %ebx, %eax
tzcntl %eax, %r14d
movq 0x8(%rsp), %rsi
movb %r14b, 0x25(%rsi)
shlxl %r14d, %r10d, %eax
orl %eax, 0x5c(%rsi)
movl 0x78(%rsi), %eax
btrl %r14d, %eax
xorl %edx, %edx
cmpb $0x14, 0x22(%rsi)
sete %dl
shlxl %r14d, %edx, %edx
orl %eax, %edx
movl %edx, 0x78(%rsi)
movl %r15d, 0x3c(%rsi,%r12,4)
movl %r15d, 0x7c(%rsi,%r14,4)
movq 0x10(%rsp), %rax
cmpb $0x2, 0xb(%rax)
movl %r9d, %edx
je 0x2580c
movq 0x10(%rsp), %rax
movzbl 0xe(%rax), %esi
testl %esi, %esi
je 0x2580a
movl %esi, %eax
movq 0x10(%rsp), %r8
movswl 0x28(%r8,%rax,2), %edi
movl %r15d, %eax
xorl %edx, %edx
divl %esi
imull %edi, %eax
movswl 0x28(%r8,%rdx,2), %edx
addl %eax, %edx
jmp 0x2580c
xorl %edx, %edx
movq 0x8(%rsp), %rax
movl %edx, 0x450(%rax,%r14,4)
movl %edx, 0x3d0(%rax,%r14,4)
cmpq $0x0, 0x188(%rax,%r14,8)
jne 0x2584f
movl %r9d, 0x28(%rsp)
movq %r13, %rdi
movl %r14d, %esi
callq 0x25940
testl %eax, %eax
jne 0x25868
movl 0x38(%r13), %ecx
movl 0x28(%rsp), %r9d
movl $0x1, %r10d
btsl %r14d, %ebx
incl %r15d
addl $0x2, %r9d
cmpl %ecx, %r15d
jb 0x2578d
jmp 0x2359b
movl $0xc, %eax
jmp 0x23635