// File: /workspace/github_c_makefile_star2_O1/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 0x23210
notl %eax
tzcntl %eax, %eax
movq %rax, 0x78(%rsp)
imulq $0x650, %rax, %rax      # imm = 0x650
movq %rax, 0x30(%rsp)
addq %rbx, %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
jne 0x22f21
movl %ecx, 0x1c(%rsp)
leaq 0x940(%rbx), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %r12d
jmp 0x22f3c
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 0x2536c
movq %r15, 0x20(%rsp)
movl %eax, 0x48(%r15)
movq %rbx, %rdi
movl $0x9, %esi
callq 0x2536c
movl $0x2, %r15d
cmpb $0x5, 0x22(%rbx)
je 0x22f82
movq 0x10(%rsp), %rcx
cmpb $0x0, 0xf(%rcx)
movl $0x2, %ecx
cmovel %ecx, %eax
movl %eax, %r15d
leal -0x5(%r15), %eax
cmpl $0x5, %r15d
movzbl %al, %eax
cmovll %r15d, %eax
movq 0x20(%rsp), %r13
movb %al, 0x20(%r13)
movq %rbx, %rdi
movl $0xff, %esi
callq 0x2536c
movl %eax, %r14d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x2302d
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movl 0x48(%r13), %ecx
movsbq 0x20(%r13), %rax
leaq 0x14b09(%rip), %rdx     # 0x37ae8
movslq (%rdx,%rax,4), %r9
addq %rdx, %r9
cmpq $0x3, %rax
leaq 0x1786e(%rip), %rax     # 0x3a85f
leaq 0x14592(%rip), %r10     # 0x3758a
movq %r10, %r11
cmovlq %rax, %r11
cmpl $0x4, %r14d
cmovlq %rax, %r10
subq $0x8, %rsp
leaq 0x167b8(%rip), %rdx     # 0x397ca
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 0x23219
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 0x23219
movq %r15, 0x70(%rsp)
cmpb $0x0, 0x222(%r13)
je 0x23219
movq 0x10(%rsp), %r14
movsbl 0xa(%r14), %esi
movq %rbx, %rdi
callq 0x1875d
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, %r14d
notl %r14d
movsbl 0x24(%r13), %eax
testl %eax, %eax
js 0x2310e
movl 0x38(%r13), %ecx
andl %r14d, %ecx
cmpl %ecx, %ebx
jne 0x23106
movl 0x70(%r13), %ecx
cmpb $0x0, 0x21(%r13)
setle %dl
btl %eax, %ecx
sbbb $0x0, %dl
je 0x23106
shrxl %eax, 0x78(%r13), %eax
cmpb $0x14, 0x22(%r13)
setne %cl
xorb %al, %cl
testb $0x1, %cl
jne 0x2310e
movq %r13, %rdi
callq 0x253d4
movl 0x3c(%r13,%r12,4), %r15d
movl %r15d, %eax
notl %eax
addl %eax, %ebx
andl %r14d, %ebx
leal (%r15,%rbx), %r8d
incl %r8d
movl %r8d, 0x38(%r13)
movzwl 0x7cb0(%r13), %eax
cmpq $0x2541, %rax           # imm = 0x2541
movq %r13, %rbx
ja 0x2316f
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movq 0x10(%rsp), %rax
movsbl 0xa(%rax), %ecx
leaq 0x166b7(%rip), %rdx     # 0x39818
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movl 0x38(%rbx), %eax
subl %r15d, %eax
cmpl $0x2, %eax
movq %rbx, 0x8(%rsp)
movq 0x20(%rsp), %r14
jge 0x25067
movw $0x0, 0x21(%r14)
movq 0x10(%rsp), %rax
cmpb $0x0, 0x10(%rax)
je 0x23259
movb 0x21(%r14), %al
notb %al
movq 0x10(%rsp), %rcx
andb 0x11(%rcx), %al
movb %al, 0x23(%r14)
cmpb $0x0, 0x23(%rbx)
je 0x23301
movq %rbx, %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x2536c
movl %eax, %r14d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23307
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16674(%rip), %rdx     # 0x3986e
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x23307
movl $0xb, %eax
testl %ebp, %ebp
je 0x2322e
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 0x2323c
jmp 0x22eba
movq %rbx, %rdi
callq 0x2551d
movb %al, 0x21(%r14)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x232a3
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movsbl %al, %ecx
leaq 0x165aa(%rip), %rdx     # 0x3983f
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
cmpb $0x0, 0x21(%r14)
je 0x2319e
movq %rbx, %rdi
callq 0x2551d
movb %al, 0x22(%r14)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x2319e
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movsbl %al, %ecx
leaq 0x16567(%rip), %rdx     # 0x39855
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x2319e
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpb $0x0, 0x24(%rbx)
js 0x2331b
cmpl 0x44(%rbx), %r14d
je 0x2331b
movq %rbx, %rdi
callq 0x253d4
movl %r14d, 0x44(%rbx)
movq 0x10(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x1, %eax
je 0x2348d
testl %eax, %eax
jne 0x23581
movq 0x10(%rsp), %r15
movsbl 0xc(%r15), %esi
movq %rbx, %rdi
callq 0x1875d
movl %eax, %r14d
movsbl 0xc(%r15), %ecx
movl $0x20, %eax
movq %rbx, %r13
movl $0x20, %ebx
subl %ecx, %ebx
cmpb $0x0, 0x24(%r13)
js 0x2337e
subl %ebx, %eax
bzhil %eax, 0x50(%r13), %eax
cmpl %eax, %r14d
je 0x2337e
movq %r13, %rdi
callq 0x253d4
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 0x233dd
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movq 0x10(%rsp), %rax
movsbl 0xc(%rax), %ecx
leaq 0x164b4(%rip), %rdx     # 0x39880
movl %r15d, %r8d
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq 0x20(%rsp), %rax
cmpb $0x0, 0x221(%rax)
movl %r15d, %r12d
je 0x23451
movq 0x20(%rsp), %rax
cmpb $0x0, 0x21(%rax)
movl %r15d, %r12d
jne 0x23451
movq %rbx, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x2555d
movl %eax, %r12d
addl %r15d, %r12d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23451
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16472(%rip), %rdx     # 0x398b2
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x235d9
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x174f0(%rip), %rdx     # 0x3a971
xorl %eax, %eax
callq 0x1070
jmp 0x235cd
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x234c7
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16406(%rip), %rdx     # 0x398bf
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
xorl %r15d, %r15d
xorl %eax, %eax
cmpb $0x0, 0x21(%rbx)
setne %dl
jne 0x234df
movq 0x10(%rsp), %rcx
movswl 0x1c(%rcx), %r15d
movq 0x10(%rsp), %rdi
movzbl 0xe(%rdi), %ecx
testl %ecx, %ecx
je 0x2350e
movl 0x38(%rbx), %esi
movb %dl, %al
addl %esi, %eax
decl %eax
movl %ecx, %edx
movswl 0x28(%rdi,%rdx,2), %esi
xorl %edx, %edx
divl %ecx
imull %esi, %eax
movswl 0x28(%rdi,%rdx,2), %ecx
addl %ecx, %r15d
addl %eax, %r15d
movswl 0x1e(%rdi), %r12d
addl %r15d, %r12d
cmpb $0x0, 0xd(%rdi)
je 0x24ec1
cmpb $0x0, 0x24(%rbx)
js 0x23534
cmpl 0x50(%rbx), %r15d
je 0x23534
movq %rbx, %rdi
callq 0x253d4
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x235d9
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
cmpl %r12d, %r15d
leaq 0x163c2(%rip), %rax     # 0x39929
leaq 0x16385(%rip), %rdx     # 0x398f3
cmoveq %rax, %rdx
movl %r15d, %ecx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x1070
jmp 0x235cd
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 0x235d6
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16350(%rip), %rdx     # 0x39910
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1070
movl %r15d, %r12d
addw %ax, 0x7cb0(%rbx)
jmp 0x235d9
movl %r15d, %r12d
movl %r15d, 0x50(%rbx)
movl %r12d, 0x54(%rbx)
cmpb $0x0, 0x24(%rbx)
movq 0x20(%rsp), %r15
js 0x2372e
movl 0x5c(%rbx), %eax
movl 0x1c(%rsp), %ecx
andl %ecx, %eax
movl %eax, 0x70(%rbx)
movl 0x60(%rbx), %eax
andl %ecx, %eax
movl %eax, 0x74(%rbx)
vmovups 0x390(%rbx), %ymm0
vmovups %ymm0, 0x3b0(%rbx)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x2365d
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movsbq 0x24(%rbx), %rax
movl 0xfc(%rbx,%rax,4), %ecx
leaq 0x162ed(%rip), %rdx     # 0x39939
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbx)
cmpb $0x1, 0x20(%r15)
jg 0x240cf
jne 0x236b7
movq %rbx, %rdi
vzeroupper
callq 0x2551d
movb %al, 0x24(%r15)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x236b7
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movsbl %al, %ecx
leaq 0x1629f(%rip), %rdx     # 0x39948
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 0x2551d
testl %eax, %eax
je 0x237ff
cmpb $0x0, 0x20(%r15)
movq %rbx, %r14
js 0x2370c
decl %ebp
movq $-0x1, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x2536c
incb %al
movb %al, 0x223(%r15,%rbx)
movsbq 0x20(%r15), %rax
incq %rbx
cmpq %rax, %rbx
jl 0x236eb
movzwl 0x7cb0(%r14), %eax
cmpl $0x2542, %eax           # imm = 0x2542
movq %r14, %rbx
jae 0x23863
leaq 0x16242(%rip), %rdx     # 0x3996b
jmp 0x2383c
movl 0x5c(%rbx), %eax
movl 0x1c(%rsp), %edx
andl %edx, %eax
popcntl %eax, %eax
movq 0x10(%rsp), %rcx
movsbl 0xf(%rcx), %ecx
cmpl %ecx, %eax
jle 0x23750
movq $0x0, 0x5c(%rbx)
movl 0x64(%rbx), %eax
orl 0x5c(%rbx), %eax
orl 0x68(%rbx), %eax
andl %edx, %eax
xorl %ecx, %ecx
popcntl %eax, %ecx
movq 0x10(%rsp), %rax
movsbl 0x13(%rax), %edx
movl $0x69, %eax
cmpl %edx, %ecx
jge 0x23219
leaq 0x1618(%rbx), %r14
leaq 0x1590(%rbx), %r15
movl 0x1c(%rsp), %r12d
movl 0x5c(%rbx), %ecx
vmovdqa 0x1760(%rbx), %xmm0
vpor 0x1750(%rbx), %xmm0, %xmm0
movl 0x64(%rbx), %eax
vmovdqa 0x1780(%rbx), %xmm1
vpternlogd $0xfe, 0x1770(%rbx), %xmm0, %xmm1
vpsrldq $0x8, %xmm1, %xmm0      # xmm0 = xmm1[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
vorpd %xmm0, %xmm1, %xmm0
vpsrlq $0x20, %xmm0, %xmm1
vpor %xmm1, %xmm0, %xmm0
vmovd %xmm0, %edx
orl 0x68(%rbx), %ecx
orl %eax, %ecx
orl %edx, %ecx
movl %ecx, %edx
andl %r12d, %edx
popcntl %edx, %edx
movq 0x10(%rsp), %rsi
movsbl 0x13(%rsi), %esi
cmpl %esi, %edx
jl 0x24f90
testl %ebp, %ebp
jne 0x25004
movq %r14, %rdi
movq %r15, %rsi
callq 0x1050
jmp 0x2378a
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
ja 0x23863
leaq 0x16157(%rip), %rdx     # 0x39993
movzwl %ax, %ecx
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x238bd
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
cmpb $0x0, 0x20(%r15)
movswq %cx, %rsi
leaq 0x1613a(%rip), %rax     # 0x399ce
leaq 0x16120(%rip), %rdx     # 0x399bb
cmoveq %rax, %rdx
movsbl 0x222(%r15), %ecx
movsbl 0x223(%r15), %r8d
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq 0x30(%rsp), %rax
addq %rbx, %rax
addq $0x1940, %rax           # imm = 0x1940
movq %rax, 0x40(%rsp)
leaq 0x7c(%rbx), %rsi
movq %rsi, 0x80(%rsp)
leaq 0x3d0(%rbx), %rcx
leaq 0x50(%rbx), %rax
leaq 0x38(%rbx), %rdx
cmpb $0x0, 0x20(%r15)
cmoveq %rsi, %rcx
cmovneq %rax, %rdx
movl (%rdx), %edx
movl $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
xorl %eax, %eax
cmpb $0x0, 0x23(%rbx)
jne 0x239c4
movl 0x70(%rbx), %esi
testl %esi, %esi
je 0x239c4
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 0x2393e
movq 0x40(%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 0x23935
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r15
cmpb $0x14, 0x22(%rbx)
jne 0x239d9
movb 0x25(%rbx), %cl
movl %eax, %edx
incl %eax
movq 0x40(%rsp), %rsi
movb %cl, (%rsi,%rdx)
testl %eax, %eax
jle 0x23a26
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 0x239f1
movb 0x1a1(%r15), %al
testb %al, %al
js 0x23a4f
movb 0x1a0(%r15), %cl
cmpb 0x1c0(%r15), %cl
jne 0x23a4f
movb %al, 0x1c0(%r15)
movb %cl, 0x1c1(%r15)
cmpb $0x0, 0x20(%r15)
js 0x23cf4
leaq 0x7cb2(%rbx), %rax
movq %rax, 0x50(%rsp)
movq 0x40(%rsp), %r14
xorl %ebp, %ebp
cmpb $0x0, 0x21(%r15)
movl 0x38(%rbx), %eax
leal 0x1(%rax,%rax), %ecx
cmovel %eax, %ecx
movl %ecx, 0x28(%rsp)
movq %rbx, %rdi
callq 0x2551d
testl %eax, %eax
je 0x23cdb
movq %r14, 0x68(%rsp)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23ace
movq %rax, %rdi
addq 0x50(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16df6(%rip), %rdx     # 0x3a8b4
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x2536c
cmpl $0x3, %eax
je 0x23c9f
movl %eax, %r14d
movl $0x1, %r12d
movq 0x68(%rsp), %r13
movq $0x0, 0x48(%rsp)
movq %r12, 0x38(%rsp)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2536c
movl %eax, %r15d
movzwl 0x7cb0(%rbx), %eax
movq %rbx, %r12
movl %r15d, %ebx
notl %ebx
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23b84
movq %rax, %rdi
addq 0x50(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
xorl %r8d, %r8d
cmpl $0x2, %r14d
leaq 0x16da6(%rip), %rcx     # 0x3a8ee
leaq 0x16d9a(%rip), %rax     # 0x3a8e9
cmoveq %rax, %rcx
leaq 0x16d8a(%rip), %rax     # 0x3a8e4
cmovlq %rax, %rcx
setne %r8b
addl %r15d, %r8d
testb $0x3, %r14b
cmovel %ebx, %r8d
leaq 0x16d64(%rip), %rdx     # 0x3a8d8
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%r12)
movsbl 0x25(%r12), %eax
cmpl $0x1, %r14d
jg 0x23bf0
incl %r15d
testl %r14d, %r14d
cmovel %ebx, %r15d
movl 0x28(%rsp), %r8d
addl %r15d, %r8d
movl 0x74(%r12), %ecx
andnl 0x70(%r12), %ecx, %ecx
movq %r12, %rbx
je 0x23c31
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), %rdi
movq 0x38(%rsp), %r12
tzcntl %ecx, %eax
movl (%rdi,%rax,4), %esi
xorl %r8d, %esi
testl %edx, %esi
je 0x23c3b
blsrl %ecx, %ecx
jne 0x23bd9
jmp 0x23c3b
cmpl $0x2, %r14d
movl 0x28(%rsp), %r8d
jne 0x23c2c
movq 0x8(%rsp), %rbx
movl 0x74(%rbx), %ecx
andl 0x70(%rbx), %ecx
movq 0x38(%rsp), %r12
je 0x23c25
tzcntl %ecx, %eax
movsbl 0x390(%rbx,%rax), %edx
cmpl %edx, %r15d
je 0x23c25
blsrl %ecx, %ecx
jne 0x23c0d
movq 0x20(%rsp), %r15
jmp 0x23c3b
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r15
movq 0x38(%rsp), %r12
movl %r8d, 0x28(%rsp)
movq %r13, %rcx
movq %r12, %rdx
movl %eax, %esi
movl %esi, %edi
movb (%rcx), %sil
movb %dil, (%rcx)
movsbq 0x222(%r15,%rbp), %rdi
cmpq %rdi, %rdx
jge 0x23c6c
movsbl %sil, %edi
incq %rdx
incq %rcx
cmpl %edi, %eax
jne 0x23c48
movq %rbx, %rdi
movl $0x5, %esi
callq 0x2536c
cmpl $0x3, %eax
je 0x23c9f
movl %eax, %r14d
movq 0x48(%rsp), %rcx
leaq 0x1(%rcx), %rax
incq %r12
incq %r13
cmpq $0x1f, %rcx
movq %rax, 0x48(%rsp)
jb 0x23afb
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2542, %rax           # imm = 0x2542
movq 0x68(%rsp), %r14
jae 0x23cdb
movq %rax, %rdi
addq 0x50(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16b83(%rip), %rdx     # 0x3a850
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
leaq 0x1(%rbp), %rax
movsbq 0x20(%r15), %rcx
addq $0x20, %r14
cmpq %rcx, %rbp
movq %rax, %rbp
jl 0x23a6d
cmpb $0x0, 0x20(%r15)
js 0x23dfa
movq 0x8(%rsp), %rax
leaq 0x7cb2(%rax), %rbx
leaq 0x16450(%rip), %r12     # 0x3a162
leaq 0x16b2e(%rip), %r13     # 0x3a847
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
movzwl 0x7cb0(%rax), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23d5e
movq %rax, %rdi
addq %rbx, %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16bab(%rip), %rdx     # 0x3a8f3
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
movq 0x8(%rsp), %rcx
addw %ax, 0x7cb0(%rcx)
movb 0x222(%r15,%r14), %al
testb %al, %al
jle 0x23ddf
xorl %ebp, %ebp
movq 0x8(%rsp), %rcx
movzwl 0x7cb0(%rcx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x23dce
movsbq %al, %rax
movq 0x40(%rsp), %rdx
movsbq (%rdx,%rbp), %r8
movq %rcx, %rdi
addq %rbx, %rdi
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
decq %rax
cmpq %rax, %rbp
movq %r13, %rdx
cmovlq %r12, %rdx
movq 0x8(%rsp), %r15
movl 0xfc(%r15,%r8,4), %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%r15)
movq 0x20(%rsp), %r15
incq %rbp
movsbq 0x222(%r15,%r14), %rax
cmpq %rax, %rbp
jl 0x23d6c
leaq 0x1(%r14), %rax
movsbq 0x20(%r15), %rcx
addq $0x20, 0x40(%rsp)
cmpq %rcx, %r14
movq %rax, %r14
jl 0x23d1c
cmpb $0x0, 0x20(%r15)
jne 0x23e0f
movb 0x224(%r15), %al
movb %al, 0x225(%r15)
cmpb $0x1, 0x225(%r15)
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %rbp
jne 0x240cf
movq %rbx, %rdi
movl $0x7, %esi
callq 0x2536c
movb %al, 0x25(%r15)
cmpb $0x0, 0x8(%rbp)
je 0x23e4f
movq %rbx, %rdi
movl $0x7, %esi
callq 0x2536c
movb %al, 0x26(%r15)
cmpb $0x0, 0x20(%r15)
js 0x240cf
leaq 0x7cb2(%rbx), %rax
movq %rax, 0x38(%rsp)
addq %rbx, 0x30(%rsp)
xorl %r12d, %r12d
movq $0x0, 0x48(%rsp)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x23eb1
movq %rax, %rdi
addq 0x38(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16a65(%rip), %rdx     # 0x3a905
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
cmpb $0x0, 0x222(%r15,%r12)
jle 0x240b3
movq %r12, %rax
shlq $0x5, %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %r14
movq %rbx, %rdi
callq 0x2551d
testl %eax, %eax
je 0x23f11
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x2555d
movq 0x30(%rsp), %r13
movw %ax, 0x1bb0(%r13,%r14,2)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x2555d
jmp 0x23f2f
movb 0x25(%r15), %al
movl $0x1, %ecx
shlxl %eax, %ecx, %eax
movq 0x30(%rsp), %r13
movw %ax, 0x1bb0(%r13,%r14,2)
xorl %eax, %eax
movb %al, 0x1d30(%r13,%r14)
cmpb $0x0, 0x8(%rbp)
je 0x23fb5
movq %rbx, %rdi
callq 0x2551d
testl %eax, %eax
je 0x23fb5
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x2555d
movq 0x30(%rsp), %r13
movw %ax, 0x1c30(%r13,%r14,2)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x2555d
movb %al, 0x1d70(%r13,%r14)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x2555d
movw %ax, 0x1cb0(%r13,%r14,2)
movq %rbx, %rdi
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movl $0x7f, %edx
callq 0x2555d
movq %r13, %rcx
jmp 0x23fe5
movb 0x26(%r15), %al
movl $0x1, %ecx
shlxl %eax, %ecx, %eax
movq 0x30(%rsp), %rcx
movw %ax, 0x1c30(%rcx,%r14,2)
movb $0x0, 0x1d70(%rcx,%r14)
movw %ax, 0x1cb0(%rcx,%r14,2)
xorl %eax, %eax
movb %al, 0x1db0(%rcx,%r14)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24099
movq %rax, %rdi
addq 0x38(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
cmpb $0x0, 0x8(%rbp)
leaq 0x16900(%rip), %rdx     # 0x3a91e
leaq 0x16936(%rip), %rax     # 0x3a95b
cmoveq %rax, %rdx
movq 0x30(%rsp), %rax
movswl 0x1bb0(%rax,%r14,2), %ecx
movsbl 0x25(%r15), %r8d
movsbl 0x1d30(%rax,%r14), %r9d
movswl 0x1c30(%rax,%r14,2), %r10d
movsbl 0x26(%r15), %r11d
movsbl 0x1d70(%rax,%r14), %r15d
movswl 0x1cb0(%rax,%r14,2), %ebp
movsbl 0x1db0(%rax,%r14), %ebx
xorl %eax, %eax
pushq %rbx
movq 0x10(%rsp), %rbx
pushq %r11
pushq %rbp
movq 0x28(%rsp), %rbp
pushq %r15
movq 0x40(%rsp), %r15
pushq %r11
pushq %r10
callq 0x1070
addq $0x30, %rsp
addw %ax, 0x7cb0(%rbx)
incq %r14
movsbq 0x222(%r15,%r12), %rax
addq 0x28(%rsp), %rax
cmpq %rax, %r14
jl 0x23ed1
leaq 0x1(%r12), %rax
movsbq 0x20(%r15), %rcx
addq $0x20, 0x48(%rsp)
cmpq %rcx, %r12
movq %rax, %r12
jl 0x23e77
cmpb $0x0, 0x21(%rbx)
je 0x24423
leaq 0x3b0(%rbx), %r14
movq %rbx, %r15
movb 0x23(%rbx), %bl
movq %r15, %rdi
vzeroupper
callq 0x2551d
movl %eax, %ebp
testb %bl, %bl
je 0x24183
movb 0x24(%r15), %al
movl $0x1, %ecx
shlxl %eax, %ecx, %eax
movl %eax, 0x70(%r15)
movq %r15, %rdi
callq 0x2551d
movzbl 0x24(%r15), %ecx
shlxl %ecx, %eax, %eax
movl %eax, 0x74(%r15)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%r14)
movzwl 0x7cb0(%r15), %edx
cmpq $0x2541, %rdx           # imm = 0x2541
movq %r15, %rbx
movq 0x20(%rsp), %r15
ja 0x24423
leaq (%rbx,%rdx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subl %edx, %esi
movswq %si, %rsi
shrxl %ecx, %eax, %r8d
leaq 0x16910(%rip), %rdx     # 0x3aa7b
movl %ebp, %ecx
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x24423
testl %ebp, %ebp
movq %r15, %rbx
je 0x243c6
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x241c8
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x16904(%rip), %rdx     # 0x3aabe
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x2536c
testl %eax, %eax
je 0x243c6
movl %eax, %ebp
leaq 0x7cb2(%rbx), %rax
movq %rax, 0x38(%rsp)
movl $0x20, %eax
subl $0x1, %eax
jb 0x243c6
movl %eax, 0x30(%rsp)
movsbl 0x24(%rbx), %r13d
xorl %r12d, %r12d
movl $0xa, %eax
btl %ebp, %eax
jae 0x2427b
movq 0x8(%rsp), %rax
movl 0x38(%rax), %ebx
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2536c
movl %eax, %r15d
notl %r15d
addl %ebx, %r15d
movq 0x8(%rsp), %rsi
movl 0x74(%rsi), %eax
andnl 0x70(%rsi), %eax, %eax
je 0x2427e
movl $0x1, %edi
tzcntl %eax, %ecx
movl 0x7c(%rsi,%rcx,4), %edx
cmpl %r15d, %edx
cmovel %ecx, %r13d
cmpl $0x1, %ebp
jne 0x24272
cmpl %r15d, %edx
jne 0x24272
shlxl %ecx, %edi, %edx
xorl %edx, 0x70(%rsi)
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
roll %cl, %edx
andl %edx, 0x74(%rsi)
movl %ecx, %r13d
blsrl %eax, %eax
jne 0x24244
jmp 0x24283
xorl %r15d, %r15d
movl $0x1, %edi
shlxl %ebp, %edi, %eax
testb $0x5c, %al
je 0x24316
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 0x2536c
movl %eax, %r12d
movl 0x74(%rbx), %eax
testl %eax, %eax
movl $0x1, %edi
je 0x242f7
cmpl $0x4, %ebp
sete %dl
tzcntl %eax, %ecx
movsbl (%r14,%rcx), %esi
cmpl %esi, %r12d
setl %sil
je 0x242e0
andb %sil, %dl
je 0x242f0
shlxl %ecx, %edi, %ecx
movq 0x8(%rsp), %rdx
xorl %ecx, 0x70(%rdx)
xorl %ecx, 0x74(%rdx)
blsrl %eax, %eax
jne 0x242c3
testb $0x48, 0x28(%rsp)
je 0x24316
movslq %r13d, %rax
movq 0x8(%rsp), %rcx
movb %r12b, 0x3b0(%rcx,%rax)
shlxl %eax, %edi, %eax
orl %eax, 0x74(%rcx)
cmpl $0x5, %ebp
movq 0x8(%rsp), %rbx
jne 0x2435d
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)
vxorps %xmm0, %xmm0, %xmm0
vmovups %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 0x243a8
movq %rax, %rdi
addq 0x38(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movslq %ebp, %rax
leaq 0x15227(%rip), %rcx     # 0x395b0
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 0x2536c
movl %eax, %ebp
testl %eax, %eax
movl 0x30(%rsp), %eax
jne 0x241f0
movl 0x70(%rbx), %eax
xorl %ecx, %ecx
popcntl %eax, %ecx
movq 0x10(%rsp), %rdx
movsbl 0xf(%rdx), %edx
cmpl %edx, %ecx
movq 0x20(%rsp), %r15
jl 0x24413
movl 0x74(%rbx), %edx
xorl %ecx, %ecx
cmpl %eax, %edx
je 0x2440d
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 0x243f3
btcl %ecx, %eax
movl %eax, 0x70(%rbx)
movb 0x24(%rbx), %al
movl $0x1, %ecx
shlxl %eax, %ecx, %eax
orl %eax, 0x70(%rbx)
movb $0x0, 0x2c(%r15)
cmpb $0x0, 0x220(%r15)
je 0x2448f
cmpb $0x2, 0x20(%r15)
je 0x2448f
movq %rbx, %rdi
movl $0x2, %esi
vzeroupper
callq 0x2536c
incb %al
movb %al, 0x2c(%r15)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x2448f
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movsbl %al, %ecx
decl %ecx
leaq 0x15558(%rip), %rdx     # 0x399d9
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 0x2555d
addb %bl, %al
movq 0x8(%rsp), %rbx
movb %al, 0x50(%r15)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x24502
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movsbl %al, %ecx
movsbl 0x226(%r15), %eax
subl %eax, %ecx
leaq 0x154fb(%rip), %rdx     # 0x399ef
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
cmpb $0x0, 0x228(%r15)
movl 0x1c(%rsp), %ebp
je 0x245f6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2536c
movb %al, 0x27(%r15)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x24575
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movsbl %al, %ecx
movsbq %al, %rax
leaq 0x135a3(%rip), %rdx     # 0x37afc
movslq (%rdx,%rax,4), %r8
addq %rdx, %r8
leaq 0x1549e(%rip), %rdx     # 0x39a05
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
cmpb $0x1, 0x27(%r15)
je 0x24602
movq %rbx, %rdi
movl $0xfffffffa, %esi       # imm = 0xFFFFFFFA
movl $0x6, %edx
callq 0x2555d
addb %al, %al
movb %al, 0x28(%r15)
movq %rbx, %rdi
movl $0xfffffffa, %esi       # imm = 0xFFFFFFFA
movl $0x6, %edx
callq 0x2555d
addb %al, %al
movb %al, 0x29(%r15)
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x24602
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movsbl 0x28(%r15), %ecx
movsbl %al, %r8d
leaq 0x15449(%rip), %rdx     # 0x39a2f
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x24602
movw $0x0, 0x27(%r15)
movb $0x0, 0x29(%r15)
cmpb $0x0, 0x23(%rbx)
je 0x24666
movl 0x64(%rbx), %eax
movb 0x24(%rbx), %cl
btrl %ecx, %eax
andl %ebp, %eax
je 0x2463d
movl $0x80000000, %ecx       # imm = 0x80000000
movl %eax, %edx
movl %ecx, %esi
tzcntl %edx, %ecx
movl 0x3d0(%rbx,%rcx,4), %ecx
cmpl %ecx, %esi
cmovgl %esi, %ecx
blsrl %edx, %edx
jne 0x2461c
addl $0x10000, %ecx          # imm = 0x10000
jmp 0x24642
movl $0x80010000, %ecx       # imm = 0x80010000
movl $0xffff0000, 0x58(%rbx) # imm = 0xFFFF0000
testl %eax, %eax
je 0x24666
tzcntl %eax, %edx
subl %ecx, 0x3d0(%rbx,%rdx,4)
subl %ecx, 0x450(%rbx,%rdx,4)
blsrl %eax, %eax
jne 0x2464d
cmpb $0x0, 0x21(%rbx)
jne 0x24672
movl 0x50(%rbx), %eax
movl %eax, 0x58(%rbx)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x246ac
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x153c6(%rip), %rdx     # 0x39a64
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
andnl 0x5c(%rbx), %ebp, %r14d
orl 0x70(%rbx), %r14d
movl 0x64(%rbx), %eax
orl %r14d, %eax
je 0x2487e
andnl 0x60(%rbx), %ebp, %eax
orl 0x74(%rbx), %eax
movl %eax, 0x30(%rsp)
leaq 0x7cb2(%rbx), %rbp
movl $0x1, %r15d
xorl %r13d, %r13d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24721
movq %rax, %rdi
addq %rbp, %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movq 0x8(%rsp), %rbx
movl 0xfc(%rbx,%r13,4), %ecx
leaq 0x15361(%rip), %rdx     # 0x39a74
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
shlxl %r13d, %r15d, %r12d
btl %r13d, %r14d
jae 0x24792
movq 0x8(%rsp), %rax
movzwl 0x7cb0(%rax), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24792
leaq 0x1533b(%rip), %rdx     # 0x39a82
testl %r12d, 0x30(%rsp)
leaq 0x1533a(%rip), %rcx     # 0x39a8d
cmoveq %rcx, %rdx
je 0x24769
movq 0x8(%rsp), %rbx
movsbl 0x390(%rbx,%r13), %ecx
jmp 0x24773
movq 0x8(%rsp), %rbx
movl 0x7c(%rbx,%r13,4), %ecx
movq %rax, %rdi
addq %rbp, %rdi
movl $0x2542, %esi           # imm = 0x2542
subl %eax, %esi
movswq %si, %rsi
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq 0x8(%rsp), %rbx
testl %r12d, 0x64(%rbx)
je 0x247e7
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x247e7
movq %rax, %rdi
addq %rbp, %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movl 0x3d0(%rbx,%r13,4), %eax
movl 0x450(%rbx,%r13,4), %ecx
cmpl %ecx, %eax
cmovsl %eax, %ecx
leaq 0x152bf(%rip), %rdx     # 0x39a98
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movl 0x78(%rbx), %eax
testl %eax, %eax
je 0x2482c
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x2482c
movq %rcx, %rdi
addq %rbp, %rdi
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
shrxl %r13d, %eax, %ecx
andl $0x1, %ecx
leaq 0x15284(%rip), %rdx     # 0x39aa2
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24861
movq %rax, %rdi
addq %rbp, %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x1611e(%rip), %rdx     # 0x3a971
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
incq %r13
movl 0x64(%rbx), %eax
orl %r14d, %eax
lzcntl %eax, %eax
movl $0x20, %ecx
subl %eax, %ecx
cmpq %rcx, %r13
jb 0x246df
vmovups (%rbx), %ymm0
movq 0x20(%rsp), %r15
vmovups %ymm0, (%r15)
cmpb $0x0, 0x20(%rbx)
je 0x248b2
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 0x249e7
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 0x249bb
jmp 0x24a33
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)
movzwl 0x512(%rsi), %eax
movw %ax, 0x34(%r15)
movzwl 0x514(%rsi), %eax
movw %ax, 0x38(%r15)
movw %ax, 0x36(%r15)
movl 0x2c(%rsi), %eax
movl %eax, 0x3c(%r15)
movl 0x30(%rsi), %eax
movl %eax, 0x40(%r15)
movsbq %bl, %rax
movl 0x48(%r15), %ecx
movb $-0x1, %dl
cmpl %ecx, 0x16d0(%rsi,%rax,4)
jne 0x24a8c
xorl %edx, %edx
cmpb $0x1, 0x21(%rsi)
sbbl %edx, %edx
orb %bl, %dl
movb %dl, 0x2d(%r15)
cmpl %ecx, 0x16d0(%rsi,%rax,4)
je 0x24aa5
movl $0x80000000, %edx       # imm = 0x80000000
cmpb $0x2, 0x27(%r15)
jne 0x24aa7
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 0x24c94
leaq 0x188(%r14), %rsi
leaq 0x60(%r15), %rdi
movl $0x100, %edx            # imm = 0x100
vzeroupper
callq 0x10c0
cmpb $0x1, %bpl
jne 0x24c94
cmpb $0x2, 0x225(%r15)
je 0x24b4d
cmpb $0x0, 0x24(%r15)
jne 0x24c94
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
orw %ax, 0x1648(%r14)
orw %ax, 0x164a(%r14)
vpbroadcastb 0x12918(%rip), %xmm0 # 0x375d4
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 0x1249a(%rip), %xmm1 # 0x37210
vpcmpeqd 0x16d0(%r14), %xmm1, %xmm2
vpcmpeqd 0x16e0(%r14), %xmm1, %xmm3
vpackssdw %xmm3, %xmm2, %xmm2
vpcmpeqd 0x16f0(%r14), %xmm1, %xmm3
vpcmpeqd 0x1700(%r14), %xmm1, %xmm4
vpcmpeqd 0x1710(%r14), %xmm1, %xmm5
vpcmpeqd 0x1720(%r14), %xmm1, %xmm6
vpackssdw %xmm4, %xmm3, %xmm3
vpackssdw %xmm6, %xmm5, %xmm4
vpcmpeqd 0x1730(%r14), %xmm1, %xmm5
vpcmpeqd 0x1740(%r14), %xmm1, %xmm1
vmovd %xmm0, %eax
vpackssdw %xmm1, %xmm5, %xmm0
vpacksswb %xmm3, %xmm2, %xmm1
vpmovmskb %xmm1, %ecx
vpacksswb %xmm0, %xmm4, %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)
movq %r14, %rbx
jne 0x24e60
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24e60
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
movq 0x70(%rsp), %rax
cmpb $0x0, (%rax)
leaq 0x14c7f(%rip), %rax     # 0x39ac3
leaq 0x14c62(%rip), %rdx     # 0x39aad
cmoveq %rax, %rdx
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movzwl 0x7cb0(%rbx), %ecx
movw $0x0, 0x7cb0(%rbx)
movl $0x5f, %eax
cmpw $0x2541, %cx            # imm = 0x2541
ja 0x23219
leaq 0x7cb2(%rbx), %rdi
movq 0x7ca8(%rbx), %rsi
vzeroupper
callq *0x7ca0(%rbx)
cmpb $0x0, 0x20(%rbx)
je 0x24eb3
addq $0x15b8, %rbx           # imm = 0x15B8
movq %rbx, %rdi
callq 0x10a0
xorl %eax, %eax
jmp 0x23219
movq %rbx, %rdi
callq *0x180(%rbx)
jmp 0x23219
movq %rbx, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x2555d
movl %eax, %r14d
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x24f13
leaq (%rbx,%rax), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movswq %cx, %rsi
leaq 0x149d7(%rip), %rdx     # 0x398d9
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
addl %r14d, %r15d
addl %r14d, %r12d
movq 0x20(%rsp), %rax
cmpb $0x0, 0x221(%rax)
je 0x23520
cmpb $0x0, 0x21(%rax)
jne 0x23520
movq %rbx, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x2555d
addl %eax, %r12d
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x23520
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
leaq 0x1496b(%rip), %rdx     # 0x398e6
movl %eax, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
jmp 0x23520
notl %ecx
tzcntl %ecx, %esi
movb %sil, 0x24(%rbx)
movl $0x1, %ecx
shlxl %esi, %ecx, %ecx
btsl %esi, %eax
movl %eax, 0x64(%rbx)
movl 0x78(%rbx), %eax
btrl %esi, %eax
xorl %edx, %edx
cmpb $0x14, 0x22(%rbx)
sete %dl
shlxl %esi, %edx, %edx
orl %eax, %edx
movl %edx, 0x78(%rbx)
xorl %ecx, 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 0x25012
movl 0xfc(%rbx,%rax,4), %eax
incl %eax
jmp 0x25014
movl $0xb, %eax
xorl %ecx, %ecx
movq 0x20(%rsp), %r15
jmp 0x2505a
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)
je 0x25047
movb $0x1, %cl
movl 0x28(%rsp), %eax
jmp 0x2505a
movq %rbx, %rdi
callq 0x2543e
testl %eax, %eax
je 0x2503f
movl $0xc, %eax
xorl %ecx, %ecx
testb %cl, %cl
jne 0x235f0
jmp 0x23219
decl %eax
movq 0x10(%rsp), %rcx
movsbl 0xf(%rcx), %edx
movl 0x60(%rbx), %ecx
movl %ecx, %esi
movl 0x1c(%rsp), %edi
andl %edi, %esi
popcntl %esi, %esi
movl %edx, %r8d
subl %esi, %r8d
cmpl %r8d, %eax
cmovll %eax, %r8d
movl 0x5c(%rbx), %eax
andl %edi, %eax
popcntl %eax, %eax
subl %edx, %eax
movl %r8d, 0x28(%rsp)
addl %r8d, %eax
testl %eax, %eax
jle 0x250ed
andnl 0x1c(%rsp), %ecx, %edx
movl 0x5c(%rbx), %ecx
movl %edx, %edi
andl %ecx, %edi
je 0x250db
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %esi, %esi
tzcntl %edi, %r9d
movl 0x7c(%rbx,%r9,4), %r10d
cmpl %r8d, %r10d
cmovll %r10d, %r8d
cmovll %r9d, %esi
blsrl %edi, %edi
jne 0x250bd
jmp 0x250dd
xorl %esi, %esi
btrl %esi, %ecx
leal -0x1(%rax), %esi
cmpl $0x1, %eax
movl %esi, %eax
jg 0x250af
movl %ecx, 0x5c(%rbx)
movl 0x5c(%rbx), %esi
movl 0x64(%rbx), %r13d
movl %esi, %eax
orl %r13d, %eax
movl %eax, %ecx
andl 0x1c(%rsp), %ecx
xorl %edi, %edi
popcntl %ecx, %edi
movq 0x10(%rsp), %rcx
movsbl 0x13(%rcx), %ecx
movl 0x28(%rsp), %edx
subl %ecx, %edx
addl %edi, %edx
testl %edx, %edx
jle 0x25188
andnl 0x1c(%rsp), %esi, %edi
movq 0x8(%rsp), %rsi
movl 0x58(%rsi), %esi
movq 0x8(%rsp), %r14
movl %edi, %r10d
andl %r13d, %r10d
je 0x25160
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
tzcntl %r10d, %r11d
movl 0x3d0(%r14,%r11,4), %ebx
cmpl %r8d, %ebx
cmovll %ebx, %r8d
cmovll %r11d, %r9d
blsrl %r10d, %r10d
jne 0x2513f
jmp 0x25169
xorl %r9d, %r9d
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
btrl %r9d, %r13d
cmpl %r8d, %esi
cmovlel %r8d, %esi
leal -0x1(%rdx), %r8d
cmpl $0x1, %edx
movl %r8d, %edx
jg 0x2512e
movq 0x8(%rsp), %rdx
movl %esi, 0x58(%rdx)
movq 0x8(%rsp), %rdx
orl 0x68(%rdx), %eax
andl 0x1c(%rsp), %eax
popcntl %eax, %eax
addl 0x28(%rsp), %eax
cmpl %ecx, %eax
jle 0x251aa
movl $0x69, %eax
jmp 0x25346
movq 0x8(%rsp), %rcx
leaq 0x1618(%rcx), %r14
leaq 0x1590(%rcx), %r15
vmovdqa 0x1760(%rcx), %xmm0
vmovdqa 0x1780(%rcx), %xmm1
vpor 0x1750(%rcx), %xmm0, %xmm0
vpternlogd $0xfe, 0x1770(%rcx), %xmm1, %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, %eax
movl 0x5c(%rcx), %ebx
orl %r13d, %ebx
orl 0x68(%rcx), %ebx
orl %eax, %ebx
andl 0x1c(%rsp), %ebx
xorl %eax, %eax
popcntl %ebx, %eax
addl 0x28(%rsp), %eax
movq 0x10(%rsp), %rcx
movsbl 0x13(%rcx), %ecx
cmpl %ecx, %eax
jle 0x25236
testl %ebp, %ebp
jne 0x25341
movq %r14, %rdi
movq %r15, %rsi
callq 0x1050
movq 0x8(%rsp), %rcx
jmp 0x251bd
movq 0x8(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, %r15d
subl 0x28(%rsp), %r15d
cmpl %eax, %r15d
setae %cl
jae 0x2534c
movl %eax, %r8d
addl %eax, %r8d
movl 0x28(%rsp), %eax
addl %eax, %eax
subl %eax, %r8d
movl $0x1, %r9d
movq 0x8(%rsp), %r13
andnl 0x1c(%rsp), %ebx, %eax
tzcntl %eax, %r14d
movb %r14b, 0x25(%r13)
shlxl %r14d, %r9d, %eax
orl %eax, 0x5c(%r13)
movl 0x78(%r13), %eax
btrl %r14d, %eax
xorl %ecx, %ecx
cmpb $0x14, 0x22(%r13)
sete %cl
shlxl %r14d, %ecx, %ecx
orl %eax, %ecx
movl %ecx, 0x78(%r13)
movl %r15d, 0x3c(%r13,%r12,4)
movl %r15d, 0x7c(%r13,%r14,4)
movq 0x10(%rsp), %rax
cmpb $0x2, 0xb(%rax)
movl %r8d, %ecx
je 0x252e8
movq 0x10(%rsp), %rax
movzbl 0xe(%rax), %ecx
testl %ecx, %ecx
je 0x252e6
movl %ecx, %eax
movq 0x10(%rsp), %rdi
movswl 0x28(%rdi,%rax,2), %esi
movl %r15d, %eax
xorl %edx, %edx
divl %ecx
imull %esi, %eax
movswl 0x28(%rdi,%rdx,2), %ecx
addl %eax, %ecx
jmp 0x252e8
xorl %ecx, %ecx
movq 0x8(%rsp), %r13
movl %ecx, 0x450(%r13,%r14,4)
movl %ecx, 0x3d0(%r13,%r14,4)
cmpq $0x0, 0x188(%r13,%r14,8)
jne 0x25327
movq %r13, %rdi
movl %r14d, %esi
movl %r8d, 0x28(%rsp)
callq 0x2543e
movl $0x1, %r9d
movl 0x28(%rsp), %r8d
testl %eax, %eax
jne 0x2534a
btsl %r14d, %ebx
incl %r15d
addl $0x2, %r8d
cmpl 0x38(%r13), %r15d
setae %cl
jb 0x2526c
jmp 0x2534c
movl $0xb, %eax
xorl %ecx, %ecx
jmp 0x25351
xorl %ecx, %ecx
movl $0xc, %eax
movl %eax, 0x28(%rsp)
testb %cl, %cl
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r14
jne 0x23188
jmp 0x23219