// File: /workspace/github_c_makefile_star2_O2/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, %r13
movl %esi, %r15d
movq %rdi, %rbp
leaq 0x1618(%rdi), %rax
movq %rax, 0x38(%rsp)
leaq 0x1590(%rdi), %r12
pushq $0xb
popq %rbx
movzwl 0x1648(%rbp), %eax
cmpw $-0x1, %ax
jne 0x1d1b1
testl %r15d, %r15d
jne 0x1d213
movq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x1050
jmp 0x1d190
notl %eax
tzcntl %eax, %eax
movq %rax, 0x78(%rsp)
imulq $0x650, %rax, %rax      # imm = 0x650
movq %rax, 0x18(%rsp)
addq %rbp, %rax
addq $0x17a0, %rax           # imm = 0x17A0
movq %r13, 0x160(%rax)
movq %r14, 0x168(%rax)
vpcmpeqd %ymm0, %ymm0, %ymm0
vmovdqu %ymm0, 0x1a0(%rax)
movq %rax, 0x8(%rsp)
vmovdqu %ymm0, 0x1c0(%rax)
movl 0x78(%rbp), %ecx
movb 0x22(%rbp), %al
cmpb $0x14, %al
jne 0x1d21b
leaq 0x940(%rbp), %rbx
pushq $0x1
popq %rax
movq %rax, 0x30(%rsp)
jmp 0x1d233
movl %ebx, %r13d
jmp 0x1f1be
notl %ecx
leaq 0x530(%rbp), %rbx
cmpb $0x5, %al
sete 0x23(%rbp)
movq $0x0, 0x30(%rsp)
movl %ecx, 0x14(%rsp)
movq %rbp, %rdi
movl $0x21fff, %esi          # imm = 0x21FFF
vzeroupper
callq 0x1f4be
movq 0x8(%rsp), %rcx
movl %eax, 0x48(%rcx)
pushq $0x9
popq %rsi
movq %rbp, %rdi
callq 0x1f4be
movb $0x2, %cl
pushq $0x2
popq %r13
cmpb $0x5, 0x22(%rbp)
movq %rbx, 0x20(%rsp)
je 0x1d280
cmpb $0x0, 0xf(%rbx)
je 0x1d280
leal -0x5(%rax), %ecx
cmpl $0x5, %eax
movzbl %cl, %ecx
cmovll %eax, %ecx
movl %eax, %r13d
movq 0x8(%rsp), %rbx
movb %cl, 0x20(%rbx)
movq %rbp, %rdi
movl $0xff, %esi
callq 0x1f4be
movl %eax, %r14d
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1d319
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movl 0x48(%rbx), %ecx
movsbq 0x20(%rbx), %rax
leaq 0x1484d(%rip), %rdx     # 0x31b18
movslq (%rdx,%rax,4), %r9
addq %rdx, %r9
cmpq $0x3, %rax
leaq 0x175b2(%rip), %rax     # 0x3488f
leaq 0x142ce(%rip), %r10     # 0x315b2
movq %r10, %r11
cmovlq %rax, %r11
cmpl $0x4, %r14d
cmovlq %rax, %r10
subq $0x8, %rsp
leaq 0x164fc(%rip), %rdx     # 0x337fa
movl %r13d, %r8d
xorl %eax, %eax
pushq %r10
pushq %r14
pushq %r11
callq 0x1070
addq $0x20, %rsp
addw %ax, 0x7cb0(%rbp)
cmpb $0x3, 0x20(%rbx)
setge %al
cmpl $0x4, %r14d
setge %cl
orb %al, %cl
pushq $0x5f
popq %rax
je 0x1d336
movl %eax, %r13d
jmp 0x1f1be
leaq 0x220(%rbx), %rdi
movslq %r14d, %rax
imulq $0x1f0, %rax, %rax      # imm = 0x1F0
leaq (%rax,%rbp), %rsi
addq $0xd50, %rsi            # imm = 0xD50
movl $0x1f0, %edx            # imm = 0x1F0
movq %rdi, 0x70(%rsp)
callq 0x10c0
pushq $0x4a
popq %r13
movq 0x20(%rsp), %r14
cmpq $0x0, (%r14)
je 0x1f1be
cmpb $0x0, 0x222(%rbx)
je 0x1f1be
movsbl 0xa(%r14), %esi
movq %rbp, %rdi
callq 0x1539a
xorl %ebx, %ebx
cmpb $0x0, 0x23(%rbp)
cmovel %eax, %ebx
movb 0xa(%r14), %al
pushq $-0x1
popq %rcx
shlxl %eax, %ecx, %r14d
notl %r14d
movsbl 0x24(%rbp), %eax
testl %eax, %eax
js 0x1d3e6
movl 0x38(%rbp), %ecx
andl %r14d, %ecx
cmpl %ecx, %ebx
jne 0x1d3de
movl 0x70(%rbp), %ecx
cmpb $0x0, 0x21(%rbp)
setle %dl
btl %eax, %ecx
sbbb $0x0, %dl
je 0x1d3de
shrxl %eax, 0x78(%rbp), %eax
cmpb $0x14, 0x22(%rbp)
setne %cl
xorb %al, %cl
testb $0x1, %cl
jne 0x1d3e6
movq %rbp, %rdi
callq 0x1f526
movq 0x30(%rsp), %rax
movl 0x3c(%rbp,%rax,4), %r13d
movl %r13d, %eax
notl %eax
addl %eax, %ebx
andl %r14d, %ebx
leal (%rbx,%r13), %r8d
incl %r8d
movl %r8d, 0x38(%rbp)
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
movq %rbp, (%rsp)
ja 0x1d452
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movq 0x20(%rsp), %r14
movsbl 0xa(%r14), %ecx
leaq 0x1640a(%rip), %rdx     # 0x33848
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movl 0x38(%rbp), %r8d
jmp 0x1d457
movq 0x20(%rsp), %r14
subl %r13d, %r8d
pushq $0x69
popq %r13
cmpl $0x2, %r8d
jge 0x1f216
movq 0x8(%rsp), %rbx
andw $0x0, 0x21(%rbx)
cmpb $0x0, 0x10(%r14)
movq (%rsp), %rbp
je 0x1d631
movb 0x21(%rbx), %al
notb %al
andb 0x11(%r14), %al
movb %al, 0x23(%rbx)
cmpb $0x0, 0x23(%rbp)
pushq $-0x1
popq %rbx
je 0x1d4e0
movq %rbp, %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x1f4be
movl %eax, %ebx
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1d4e0
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x163ce(%rip), %rdx     # 0x3389e
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
cmpb $0x0, 0x24(%rbp)
js 0x1d4f3
cmpl 0x44(%rbp), %ebx
je 0x1d4f3
movq %rbp, %rdi
callq 0x1f526
movl %ebx, 0x44(%rbp)
movzbl 0xb(%r14), %eax
pushq $0x20
popq %rcx
movl %ecx, 0x54(%rsp)
cmpl $0x1, %eax
je 0x1d6df
testl %eax, %eax
jne 0x1d7e2
movsbl 0xc(%r14), %esi
movq %rbp, %rdi
callq 0x1539a
movq %r14, %rcx
movl %eax, %r14d
movsbl 0xc(%rcx), %eax
pushq $0x20
popq %rbx
subl %eax, %ebx
cmpb $0x0, 0x24(%rbp)
js 0x1d54d
pushq $0x20
popq %rax
subl %ebx, %eax
bzhil %eax, 0x50(%rbp), %eax
cmpl %eax, %r14d
je 0x1d54d
movq %rbp, %rdi
callq 0x1f526
movq 0x30(%rsp), %rax
movl 0x48(%rbp,%rax,4), %eax
subl %eax, %r14d
shlxl %ebx, %r14d, %ecx
sarxl %ebx, %ecx, %r14d
addl %eax, %r14d
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1d5b0
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movq 0x20(%rsp), %rax
movsbl 0xc(%rax), %ecx
leaq 0x16318(%rip), %rdx     # 0x338b0
movl %r14d, %r8d
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
movq 0x8(%rsp), %rcx
cmpb $0x0, 0x221(%rcx)
je 0x1d834
cmpb $0x0, 0x21(%rcx)
movl %r14d, %ebx
jne 0x1d837
movq %rbp, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1f6a0
movl %eax, %ebx
addl %r14d, %ebx
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1d86a
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x162cd(%rip), %rdx     # 0x338e2
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
jmp 0x1d837
movq %rbp, %rdi
callq 0x1f662
movb %al, 0x21(%rbx)
movzwl 0x7cb0(%rbp), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x1d681
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
leaq 0x16204(%rip), %rdx     # 0x3386f
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movq 0x8(%rsp), %rax
movb 0x21(%rax), %al
testb %al, %al
movq 0x8(%rsp), %rbx
je 0x1d481
movq %rbp, %rdi
callq 0x1f662
movb %al, 0x22(%rbx)
movzwl 0x7cb0(%rbp), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x1d481
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
leaq 0x161b9(%rip), %rdx     # 0x33885
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
jmp 0x1d481
movzwl 0x7cb0(%rbp), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x1d720
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rcx, %rsi
leaq 0x161e6(%rip), %rdx     # 0x338ef
xorl %eax, %eax
callq 0x1070
movl %eax, %ecx
addw 0x7cb0(%rbp), %cx
movw %cx, 0x7cb0(%rbp)
xorl %r14d, %r14d
xorl %eax, %eax
cmpb $0x0, 0x21(%rbp)
setne %dl
jne 0x1d738
movq 0x20(%rsp), %rsi
movswl 0x1c(%rsi), %r14d
movq 0x20(%rsp), %r8
movzbl 0xe(%r8), %esi
testl %esi, %esi
je 0x1d76a
movl 0x38(%rbp), %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, %r14d
addl %eax, %r14d
movswl 0x1e(%r8), %ebx
addl %r14d, %ebx
cmpb $0x0, 0xd(%r8)
je 0x1e5dd
cmpb $0x0, 0x24(%rbp)
js 0x1d798
cmpl 0x50(%rbp), %r14d
je 0x1d798
movq %rbp, %rdi
callq 0x1f526
movzwl 0x7cb0(%rbp), %ecx
cmpw $0x2541, %cx            # imm = 0x2541
ja 0x1d86a
movzwl %cx, %eax
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %eax           # imm = 0x2542
subl %ecx, %eax
movzwl %ax, %esi
cmpl %ebx, %r14d
leaq 0x16194(%rip), %rax     # 0x33959
leaq 0x16157(%rip), %rdx     # 0x33923
cmoveq %rax, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1070
jmp 0x1d863
movl 0x38(%rbp), %eax
xorl %ecx, %ecx
cmpb $0x0, 0x21(%rbp)
setne %cl
leal (%rcx,%rax,2), %r14d
decl %r14d
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1d82f
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x16120(%rip), %rdx     # 0x33940
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
movl %r14d, %ebx
jmp 0x1d863
movl %r14d, %ebx
jmp 0x1d86a
movl %r14d, %ebx
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1d86a
movzwl %ax, %ecx
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x17145(%rip), %rdx     # 0x349a1
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movl %r14d, 0x50(%rbp)
movl %ebx, 0x54(%rbp)
cmpb $0x0, 0x24(%rbp)
movq 0x20(%rsp), %rbx
js 0x1d9a8
vmovq 0x5c(%rbp), %xmm0
movl 0x14(%rsp), %eax
vpbroadcastd %eax, %xmm1
vpand %xmm1, %xmm0, %xmm0
vmovq %xmm0, 0x70(%rbp)
vmovdqu 0x390(%rbp), %ymm0
vmovdqu %ymm0, 0x3b0(%rbp)
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1d8f0
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movsbq 0x24(%rbp), %rax
movl 0xfc(%rbp,%rax,4), %ecx
leaq 0x1608a(%rip), %rdx     # 0x33969
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movq 0x8(%rsp), %r12
cmpb $0x1, 0x20(%r12)
jg 0x1e2fa
jne 0x1d950
movq %rbp, %rdi
vzeroupper
callq 0x1f662
movb %al, 0x24(%r12)
movzwl 0x7cb0(%rbp), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x1d950
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
leaq 0x16036(%rip), %rdx     # 0x33978
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movb 0x21(%r12), %al
pushq $0x10
popq %rcx
shlxl %eax, %ecx, %r14d
movq %rbp, %rdi
vzeroupper
callq 0x1f662
testl %eax, %eax
je 0x1da7c
decl %r14d
xorl %ebx, %ebx
movq 0x18(%rsp), %rcx
movsbq 0x20(%r12), %rax
cmpq %rax, %rbx
jg 0x1da62
movq %rbp, %rdi
movl %r14d, %esi
callq 0x1f4be
movq 0x18(%rsp), %rcx
incb %al
movb %al, 0x222(%r12,%rbx)
incq %rbx
jmp 0x1d97a
movl 0x5c(%rbp), %edx
movl %edx, %eax
movl 0x14(%rsp), %edi
andl %edi, %eax
popcntl %eax, %eax
movsbl 0xf(%rbx), %ecx
cmpl %ecx, %eax
jle 0x1d9c6
andq $0x0, 0x5c(%rbp)
xorl %edx, %edx
movl 0x64(%rbp), %eax
movl 0x68(%rbp), %ecx
movl %eax, %esi
orl %edx, %esi
orl %ecx, %esi
andl %edi, %esi
popcntl %esi, %edi
movsbl 0x13(%rbx), %esi
cmpl %esi, %edi
jge 0x1f1be
movl 0x14(%rsp), %r14d
vmovdqa 0x1760(%rbp), %xmm0
vmovdqa 0x1780(%rbp), %xmm1
vpor 0x1750(%rbp), %xmm0, %xmm0
vpternlogd $0xfe, 0x1770(%rbp), %xmm1, %xmm0
orl %edx, %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, %edx
orl %eax, %ecx
orl %edx, %ecx
movl %ecx, %edx
andl %r14d, %edx
popcntl %edx, %edx
movsbl %sil, %esi
cmpl %esi, %edx
jl 0x1e6bb
testl %r15d, %r15d
jne 0x1f3b5
movq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x1050
movl 0x5c(%rbp), %edx
movl 0x64(%rbp), %eax
movl 0x68(%rbp), %ecx
movb 0x13(%rbx), %sil
jmp 0x1d9e9
movzwl 0x7cb0(%rbp), %eax
cmpw $0x2542, %ax            # imm = 0x2542
jae 0x1db56
leaq 0x15f21(%rip), %rdx     # 0x3399b
jmp 0x1dac9
movsbl 0x222(%r12), %eax
cmpl %r14d, %eax
cmovgel %r14d, %eax
movb %al, 0x222(%r12)
movsbl 0x223(%r12), %eax
cmpl %r14d, %eax
cmovll %eax, %r14d
movb %r14b, 0x223(%r12)
movzwl 0x7cb0(%rbp), %eax
cmpw $0x2541, %ax            # imm = 0x2541
movq 0x18(%rsp), %rcx
ja 0x1db56
leaq 0x15efa(%rip), %rdx     # 0x339c3
movzwl %ax, %ecx
leaq (%rcx,%rbp), %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(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
cmpw $0x2541, %ax            # imm = 0x2541
movq 0x18(%rsp), %rcx
ja 0x1db56
movzwl %ax, %ecx
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
subl %eax, %ebx
cmpb $0x0, 0x20(%r12)
movzwl %bx, %esi
leaq 0x15ed8(%rip), %rax     # 0x339fe
leaq 0x15ebe(%rip), %rdx     # 0x339eb
cmoveq %rax, %rdx
movsbl 0x222(%r12), %ecx
movsbl 0x223(%r12), %r8d
xorl %eax, %eax
callq 0x1070
movq 0x18(%rsp), %rcx
addw %ax, 0x7cb0(%rbp)
leaq (%rcx,%rbp), %rax
addq $0x1940, %rax           # imm = 0x1940
movq %rax, 0x48(%rsp)
leaq 0x7c(%rbp), %r15
leaq 0x3d0(%rbp), %rcx
leaq 0x50(%rbp), %rax
leaq 0x38(%rbp), %rdx
cmpb $0x0, 0x20(%r12)
cmoveq %r15, %rcx
cmovneq %rax, %rdx
movl (%rdx), %edx
andl $0x0, 0x60(%rsp)
andq $0x0, 0x58(%rsp)
xorl %eax, %eax
cmpb $0x0, 0x23(%rbp)
je 0x1dfaa
cmpb $0x14, 0x22(%rbp)
jne 0x1dbb4
movb 0x25(%rbp), %cl
movl %eax, %edx
incl %eax
movq 0x48(%rsp), %rsi
movb %cl, (%rsi,%rdx)
movslq 0x58(%rsp), %rcx
movslq 0x5c(%rsp), %rdx
movq %rdx, %rsi
addq %rcx, %rsi
movl %eax, %edi
sarl $0x1f, %edi
andnl %eax, %edi, %eax
xorl %edi, %edi
cmpq %rdi, %rax
je 0x1dc07
cmpq %rsi, %rdi
movl $0x0, %r8d
cmovll %ecx, %r8d
negl %r8d
cmpq %rcx, %rdi
cmovll %edx, %r8d
addl %edi, %r8d
movb 0x1a0(%r12,%rdi), %r9b
movslq %r8d, %r8
movb %r9b, 0x1c0(%r12,%r8)
incq %rdi
jmp 0x1dbd0
movb 0x1a1(%r12), %al
testb %al, %al
js 0x1dc35
movb 0x1a0(%r12), %cl
cmpb 0x1c0(%r12), %cl
jne 0x1dc35
movb %al, 0x1c0(%r12)
movb %cl, 0x1c1(%r12)
leaq 0x7cb2(%rbp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
xorl %r14d, %r14d
movq %r15, 0x80(%rsp)
movsbq 0x20(%r12), %rax
cmpq %rax, %r14
jg 0x1deb3
cmpb $0x0, 0x21(%r12)
movl 0x38(%rbp), %eax
leal 0x1(%rax,%rax), %ebx
cmovel %eax, %ebx
movq %rbp, %rdi
callq 0x1f662
testl %eax, %eax
je 0x1dea5
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1dcbe
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x16c37(%rip), %rdx     # 0x348e4
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movq 0x68(%rsp), %r13
pushq $0x1
popq %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %rbp, %rdi
pushq $0x5
popq %rsi
callq 0x1f4be
cmpl $0x3, %eax
je 0x1de6a
movl %eax, %r12d
movq 0x38(%rsp), %rax
andl $-0x20, %eax
jne 0x1de6a
movq %r13, 0x28(%rsp)
movq %rbp, %rdi
pushq $-0x2
popq %rsi
callq 0x1f4be
movl %eax, %r13d
movzwl 0x7cb0(%rbp), %eax
movq %rbp, %r15
movl %r13d, %ebp
notl %ebp
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1dd7e
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
xorl %r8d, %r8d
cmpl $0x2, %r12d
leaq 0x16bdb(%rip), %rcx     # 0x3491e
leaq 0x16bcf(%rip), %rax     # 0x34919
cmoveq %rax, %rcx
leaq 0x16bbf(%rip), %rax     # 0x34914
cmovlq %rax, %rcx
setne %r8b
addl %r13d, %r8d
testb $0x3, %r12b
cmovel %ebp, %r8d
leaq 0x16b99(%rip), %rdx     # 0x34908
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%r15)
movsbl 0x25(%r15), %eax
cmpl $0x1, %r12d
jg 0x1dde5
incl %r13d
testl %r12d, %r12d
cmovel %ebp, %r13d
addl %r13d, %ebx
movq 0x20(%rsp), %rcx
movb 0xa(%rcx), %cl
pushq $-0x1
popq %rdx
shlxl %ecx, %edx, %ecx
notl %ecx
movl 0x74(%r15), %edx
andnl 0x70(%r15), %edx, %edx
movq %r15, %rbp
movq 0x8(%rsp), %r8
movq 0x80(%rsp), %r15
movq 0x28(%rsp), %r13
movq 0x30(%rsp), %r9
testl %edx, %edx
je 0x1de29
tzcntl %edx, %eax
movl (%r15,%rax,4), %esi
xorl %ebx, %esi
testl %ecx, %esi
je 0x1de29
blsrl %edx, %edx
jmp 0x1ddcc
cmpl $0x2, %r12d
movq 0x30(%rsp), %r9
jne 0x1de1b
movq (%rsp), %rbp
movl 0x74(%rbp), %ecx
andl 0x70(%rbp), %ecx
movq 0x8(%rsp), %r8
testl %ecx, %ecx
je 0x1de24
tzcntl %ecx, %eax
movsbl 0x390(%rbp,%rax), %edx
cmpl %edx, %r13d
je 0x1de24
blsrl %ecx, %ecx
jmp 0x1ddff
movq (%rsp), %rbp
movq 0x8(%rsp), %r8
movq 0x28(%rsp), %r13
movq %r13, %rcx
movq %r9, %rdx
movl %eax, %esi
movl %esi, %edi
movb (%rcx), %sil
movb %dil, (%rcx)
movsbq 0x222(%r8,%r14), %rdi
cmpq %rdi, %rdx
jge 0x1de55
movsbl %sil, %edi
incq %rdx
incq %rcx
cmpl %edi, %eax
jne 0x1de31
incq 0x38(%rsp)
incq %r9
movq %r9, 0x30(%rsp)
incq %r13
jmp 0x1dcd4
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2542, %rax           # imm = 0x2542
movq 0x8(%rsp), %r12
jae 0x1dea5
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x169e9(%rip), %rdx     # 0x34880
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
incq %r14
addq $0x20, 0x68(%rsp)
jmp 0x1dc56
leaq 0x16a69(%rip), %r14     # 0x34923
leaq 0x162d1(%rip), %rbx     # 0x34192
leaq 0x169af(%rip), %r12     # 0x34877
xorl %r15d, %r15d
movsbq %al, %rcx
cmpq %rcx, %r15
jg 0x1df90
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1df13
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax), %rdi
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movq %r14, %rdx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
xorl %r13d, %r13d
movq 0x8(%rsp), %rcx
movsbq 0x222(%rcx,%r15), %rcx
cmpq %rcx, %r13
jge 0x1df7a
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1df75
movq 0x48(%rsp), %rdx
movsbq (%rdx,%r13), %r8
movl $0x2542, %edx           # imm = 0x2542
subl %eax, %edx
movzwl %ax, %edi
addq 0x40(%rsp), %rdi
movzwl %dx, %esi
decq %rcx
cmpq %rcx, %r13
movq %r12, %rdx
cmovlq %rbx, %rdx
movl 0xfc(%rbp,%r8,4), %ecx
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
incq %r13
jmp 0x1df16
incq %r15
movq 0x8(%rsp), %rax
movb 0x20(%rax), %al
addq $0x20, 0x48(%rsp)
jmp 0x1decb
testb %al, %al
je 0x1e031
movq 0x8(%rsp), %r12
movb 0x225(%r12), %al
jmp 0x1e046
movl 0x70(%rbp), %esi
xorl %eax, %eax
xorl %edi, %edi
testl %esi, %esi
je 0x1db9f
movl 0x74(%rbp), %r9d
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl %esi, %r10d
testl %r10d, %r10d
je 0x1e014
tzcntl %r10d, %r11d
movl (%rcx,%r11,4), %ebx
subl %edx, %ebx
movl %ebx, %ebp
negl %ebp
leal 0x10000(%rbx), %r14d
testl %ebx, %ebx
cmovlel %ebp, %r14d
movq (%rsp), %rbp
movsbl 0x390(%rbp,%r11), %ebx
addl $0x20000, %ebx          # imm = 0x20000
btl %r11d, %r9d
cmovael %r14d, %ebx
cmpl %r8d, %ebx
cmovll %ebx, %r8d
cmovll %r11d, %edi
blsrl %r10d, %r10d
jmp 0x1dfc6
movq 0x48(%rsp), %r9
movb %dil, (%r9,%rax)
incq %rax
sarl $0x10, %r8d
movslq %r8d, %r8
incl 0x58(%rsp,%r8,4)
btcl %edi, %esi
jmp 0x1dfb1
movq 0x8(%rsp), %r12
movb 0x224(%r12), %al
movb %al, 0x225(%r12)
cmpb $0x1, %al
jne 0x1e2fa
pushq $0x7
popq %rsi
movq %rbp, %rdi
callq 0x1f4be
movb %al, 0x25(%r12)
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x1e079
pushq $0x7
popq %rsi
movq %rbp, %rdi
callq 0x1f4be
movb %al, 0x26(%r12)
addq %rbp, 0x18(%rsp)
xorl %r15d, %r15d
xorl %ebx, %ebx
movsbq 0x20(%r12), %rax
cmpq %rax, %r15
jg 0x1e2fa
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1e0cb
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x1687b(%rip), %rdx     # 0x34935
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movq %r15, %rax
shlq $0x5, %rax
movq %rax, 0x38(%rsp)
movq %rbx, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movsbq 0x222(%r12,%r15), %rax
addq 0x38(%rsp), %rax
cmpq %rax, %rbx
jge 0x1e2e9
movq %rbp, %rdi
callq 0x1f662
testl %eax, %eax
je 0x1e141
movq %rbp, %rdi
movq %r12, %r14
pushq $-0x80
popq %r12
movl %r12d, %esi
movq %rbp, %r15
pushq $0x7f
popq %rbp
movl %ebp, %edx
callq 0x1f6a0
movq 0x18(%rsp), %r13
movw %ax, 0x1bb0(%r13,%rbx,2)
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %r12
movl %ebp, %edx
movq %r15, %rbp
callq 0x1f6a0
jmp 0x1e15e
movb 0x25(%r12), %al
pushq $0x1
popq %rcx
shlxl %eax, %ecx, %eax
movq 0x18(%rsp), %r13
movw %ax, 0x1bb0(%r13,%rbx,2)
xorl %eax, %eax
movb %al, 0x1d30(%r13,%rbx)
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x1e1f0
movq %rbp, %rdi
callq 0x1f662
testl %eax, %eax
je 0x1e1f0
movq %rbp, %rdi
pushq $-0x80
popq %r12
movl %r12d, %esi
movq %rbp, %r14
pushq $0x7f
popq %rbp
movl %ebp, %edx
callq 0x1f6a0
movq 0x18(%rsp), %r13
movw %ax, 0x1c30(%r13,%rbx,2)
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x1f6a0
movb %al, 0x1d70(%r13,%rbx)
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x1f6a0
movw %ax, 0x1cb0(%r13,%rbx,2)
movq %r14, %rdi
movl %r12d, %esi
movq 0x8(%rsp), %r12
movl %ebp, %edx
movq %r14, %rbp
callq 0x1f6a0
movb %al, 0x1db0(%r13,%rbx)
movsbl %al, %r10d
jmp 0x1e225
movb 0x26(%r12), %al
pushq $0x1
popq %rcx
shlxl %eax, %ecx, %eax
movq 0x18(%rsp), %rcx
movw %ax, 0x1c30(%rcx,%rbx,2)
xorl %r10d, %r10d
movb %r10b, 0x1d70(%rcx,%rbx)
movw %ax, 0x1cb0(%rcx,%rbx,2)
movb %r10b, 0x1db0(%rcx,%rbx)
movq 0x30(%rsp), %r15
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1e2e1
movq %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8(%rax)
leaq 0x166ef(%rip), %rdx     # 0x3494e
leaq 0x16725(%rip), %rax     # 0x3498b
cmoveq %rax, %rdx
movq 0x18(%rsp), %rax
movswl 0x1bb0(%rax,%rbx,2), %ecx
movsbl 0x25(%r12), %r8d
movq 0x18(%rsp), %rax
movsbl 0x1d30(%rax,%rbx), %r9d
movq 0x18(%rsp), %rax
movswl 0x1c30(%rax,%rbx,2), %r11d
movsbl 0x26(%r12), %r14d
movq 0x18(%rsp), %rax
movsbl 0x1d70(%rax,%rbx), %r12d
movq 0x18(%rsp), %rax
movswl 0x1cb0(%rax,%rbx,2), %ebp
xorl %eax, %eax
pushq %r10
pushq %r14
pushq %rbp
movq 0x18(%rsp), %rbp
pushq %r12
movq 0x28(%rsp), %r12
pushq %r14
pushq %r11
callq 0x1070
addq $0x30, %rsp
addw %ax, 0x7cb0(%rbp)
incq %rbx
jmp 0x1e0e1
incq %r15
movq 0x28(%rsp), %rbx
addq $0x20, %rbx
jmp 0x1e083
cmpb $0x0, 0x21(%rbp)
je 0x1e767
leaq 0x3b0(%rbp), %r14
movb 0x23(%rbp), %bl
movq %rbp, %rdi
vzeroupper
callq 0x1f662
movl %eax, %r15d
testb %bl, %bl
je 0x1e399
movb 0x24(%rbp), %al
pushq $0x1
popq %rcx
shlxl %eax, %ecx, %eax
movl %eax, 0x70(%rbp)
movq %rbp, %rdi
callq 0x1f662
movzbl 0x24(%rbp), %ecx
shlxl %ecx, %eax, %eax
movl %eax, 0x74(%rbp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, (%r14)
movzwl 0x7cb0(%rbp), %edx
cmpq $0x2541, %rdx           # imm = 0x2541
ja 0x1e767
leaq (%rdx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subl %edx, %esi
movzwl %si, %esi
shrxl %ecx, %eax, %r8d
leaq 0x1672b(%rip), %rdx     # 0x34aab
movl %r15d, %ecx
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbp)
jmp 0x1e767
testl %r15d, %r15d
je 0x1e5bb
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1e3db
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x16721(%rip), %rdx     # 0x34aee
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
leaq 0x7cb2(%rbp), %rax
movq %rax, 0x38(%rsp)
movq %rbp, %rdi
pushq $0x6
popq %rsi
vzeroupper
callq 0x1f4be
testl %eax, %eax
je 0x1e5bb
subl $0x1, 0x54(%rsp)
jb 0x1e5bb
movl %eax, %r15d
movsbl 0x24(%rbp), %ebx
xorl %r13d, %r13d
pushq $0xa
popq %rax
btl %r15d, %eax
jae 0x1e481
movq (%rsp), %rax
movl 0x38(%rax), %ebp
movq (%rsp), %rdi
pushq $-0x2
popq %rsi
callq 0x1f4be
movl %eax, %r12d
notl %r12d
addl %ebp, %r12d
movq (%rsp), %r8
movl 0x70(%r8), %eax
movl 0x74(%r8), %ecx
andnl %eax, %ecx, %edx
testl %edx, %edx
je 0x1e484
tzcntl %edx, %esi
movl 0x7c(%r8,%rsi,4), %edi
cmpl %r12d, %edi
cmovel %esi, %ebx
cmpl $0x1, %r15d
jne 0x1e476
cmpl %r12d, %edi
jne 0x1e476
btcl %esi, %eax
movl %eax, 0x70(%r8)
btrl %esi, %ecx
movl %ecx, 0x74(%r8)
jmp 0x1e478
movl %ebx, %esi
blsrl %edx, %edx
movl %esi, %ebx
jmp 0x1e448
xorl %r12d, %r12d
pushq $0x1
popq %rax
shlxl %r15d, %eax, %eax
testb $0x5c, %al
je 0x1e520
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsbl 0xf(%rax), %esi
xorl %eax, %eax
cmpl $0x4, %r15d
setne %al
subl %eax, %esi
movq (%rsp), %rbp
movq %rbp, %rdi
callq 0x1f4be
movl %eax, %r13d
movl 0x74(%rbp), %eax
movl %eax, %ecx
testl %ecx, %ecx
je 0x1e4ff
cmpl $0x4, %r15d
sete %sil
tzcntl %ecx, %edx
movsbl (%r14,%rdx), %edi
cmpl %edi, %r13d
setl %dil
je 0x1e4e3
andb %dil, %sil
je 0x1e4f8
pushq $0x1
popq %rsi
shlxl %edx, %esi, %esi
movq (%rsp), %rdi
xorl %esi, 0x70(%rdi)
btcl %edx, %eax
movl %eax, 0x74(%rdi)
blsrl %ecx, %ecx
jmp 0x1e4c0
testb $0x48, 0x18(%rsp)
je 0x1e520
movslq %ebx, %rax
movq (%rsp), %rcx
movb %r13b, 0x3b0(%rcx,%rax)
pushq $0x1
popq %rdx
shlxl %eax, %edx, %eax
orl %eax, 0x74(%rcx)
cmpl $0x5, %r15d
movq (%rsp), %rbp
jne 0x1e568
movb $0x1, 0x23(%rbp)
andl $0x0, 0x70(%rbp)
movsbq 0x24(%rbp), %rax
andl $0x0, 0x7c(%rbp,%rax,4)
andl $0x0, 0x74(%rbp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, (%r14)
movl 0x50(%rbp), %ecx
movl 0x54(%rbp), %edx
cmpl %edx, %ecx
movl %edx, %esi
cmovsl %ecx, %esi
subl %esi, %ecx
movl %ecx, 0x3d0(%rbp,%rax,4)
subl %esi, %edx
movl %edx, 0x450(%rbp,%rax,4)
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1e3e7
movq %rax, %rdi
addq 0x38(%rsp), %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movslq %r15d, %rax
leaq 0x15049(%rip), %rcx     # 0x335e0
movslq -0x4(%rcx,%rax,4), %rdx
addq %rcx, %rdx
movl %r12d, %ecx
movl %r13d, %r8d
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbp)
jmp 0x1e3e7
movl 0x70(%rbp), %eax
popcntl %eax, %ecx
movq 0x20(%rsp), %rdx
movsbl 0xf(%rdx), %edx
cmpl %edx, %ecx
jge 0x1e72c
movq 0x8(%rsp), %r12
jmp 0x1e75e
movq %rbp, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1f6a0
movzwl 0x7cb0(%rbp), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x1e63a
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rcx, %rsi
leaq 0x152f0(%rip), %rdx     # 0x33909
movl %eax, %ecx
movl %eax, 0x30(%rsp)
xorl %eax, %eax
callq 0x1070
movl %eax, %ecx
movl 0x30(%rsp), %eax
addw 0x7cb0(%rbp), %cx
movw %cx, 0x7cb0(%rbp)
addl %eax, %r14d
addl %eax, %ebx
movq 0x8(%rsp), %rax
cmpb $0x0, 0x221(%rax)
je 0x1d77d
cmpb $0x0, 0x21(%rax)
jne 0x1d77d
movq %rbp, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1f6a0
addl %eax, %ebx
movzwl 0x7cb0(%rbp), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x1d77d
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rcx, %rsi
leaq 0x15279(%rip), %rdx     # 0x33916
movl %eax, %ecx
xorl %eax, %eax
callq 0x1070
movl %eax, %ecx
addw 0x7cb0(%rbp), %cx
movw %cx, 0x7cb0(%rbp)
jmp 0x1d77d
notl %ecx
tzcntl %ecx, %esi
movb %sil, 0x24(%rbp)
pushq $0x1
popq %rcx
shlxl %esi, %ecx, %ecx
btsl %esi, %eax
movl %eax, 0x64(%rbp)
movl 0x78(%rbp), %eax
btrl %esi, %eax
xorl %edx, %edx
cmpb $0x14, 0x22(%rbp)
sete %dl
shlxl %esi, %edx, %edx
orl %eax, %edx
movl %edx, 0x78(%rbp)
xorl %ecx, 0x6c(%rbp)
movzwl 0x4(%rbx), %eax
movswl 0x6(%rbx), %ecx
imull %eax, %ecx
movl %ecx, 0x1650(%rbp,%rsi,4)
andl $0x0, 0x16d0(%rbp,%rsi,4)
movl 0x38(%rbp), %eax
movl %eax, 0x7c(%rbp,%rsi,4)
movsbq 0x25(%rbp), %rax
testq %rax, %rax
js 0x1f1d3
movl 0xfc(%rbp,%rax,4), %eax
incl %eax
jmp 0x1f1d5
movl 0x74(%rbp), %edx
xorl %eax, %edx
xorl %ecx, %ecx
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq 0x8(%rsp), %r12
testl %edx, %edx
je 0x1e75b
tzcntl %edx, %edi
movl 0x7c(%rbp,%rdi,4), %r8d
cmpl %r8d, %esi
cmovgel %r8d, %esi
cmovgl %edi, %ecx
blsrl %edx, %edx
jmp 0x1e73d
btcl %ecx, %eax
movb 0x24(%rbp), %cl
btsl %ecx, %eax
movl %eax, 0x70(%rbp)
movb $0x0, 0x2c(%r12)
cmpb $0x0, 0x220(%r12)
je 0x1e7d4
cmpb $0x2, 0x20(%r12)
je 0x1e7d4
pushq $0x2
popq %rsi
movq %rbp, %rdi
vzeroupper
callq 0x1f4be
incb %al
movb %al, 0x2c(%r12)
movzwl 0x7cb0(%rbp), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x1e7d4
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movsbl %al, %ecx
decl %ecx
leaq 0x15243(%rip), %rdx     # 0x33a09
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbp)
movsbl 0x226(%r12), %ebx
pushq $0x33
popq %rdx
subl %ebx, %edx
movl %ebx, %esi
negl %esi
movq %rbp, %rdi
vzeroupper
callq 0x1f6a0
movl %eax, %ecx
addb %bl, %cl
movb %cl, 0x50(%r12)
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1e846
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movsbl %cl, %ecx
movsbl 0x226(%r12), %eax
subl %eax, %ecx
leaq 0x151ee(%rip), %rdx     # 0x33a1f
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
cmpb $0x0, 0x228(%r12)
movl 0x14(%rsp), %ebx
je 0x1e94e
pushq $0x2
popq %rsi
movq %rbp, %rdi
callq 0x1f4be
movl %eax, %edx
movb %dl, 0x27(%r12)
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1e8c3
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movsbl %dl, %ecx
movsbq %dl, %rax
leaq 0x13291(%rip), %rdx     # 0x31b2c
movslq (%rdx,%rax,4), %r8
addq %rdx, %r8
leaq 0x1518c(%rip), %rdx     # 0x33a35
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
movb 0x27(%r12), %dl
cmpb $0x1, %dl
je 0x1e95b
pushq $-0x6
popq %r15
pushq $0x6
popq %r14
movq %rbp, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x1f6a0
addb %al, %al
movb %al, 0x28(%r12)
movq %rbp, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl 0x14(%rsp), %ebx
callq 0x1f6a0
movl %eax, %edx
addb %dl, %dl
movb %dl, 0x29(%r12)
movzwl 0x7cb0(%rbp), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1e95b
leaq (%rax,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movsbl 0x28(%r12), %ecx
movsbl %dl, %r8d
leaq 0x15128(%rip), %rdx     # 0x33a5f
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
jmp 0x1e95b
andw $0x0, 0x27(%r12)
movb $0x0, 0x29(%r12)
cmpb $0x0, 0x23(%rbp)
je 0x1e9b8
movl 0x64(%rbp), %ecx
movb 0x24(%rbp), %dl
btrl %edx, %ecx
andl %ebx, %ecx
movl $0x80000000, %edx       # imm = 0x80000000
movl %ecx, %esi
testl %esi, %esi
je 0x1e98e
tzcntl %esi, %edi
movl 0x3d0(%rbp,%rdi,4), %edi
cmpl %edi, %edx
cmovlel %edi, %edx
blsrl %esi, %esi
jmp 0x1e973
movl $0xffff0000, 0x58(%rbp) # imm = 0xFFFF0000
addl $0x10000, %edx          # imm = 0x10000
testl %ecx, %ecx
je 0x1e9b8
tzcntl %ecx, %esi
subl %edx, 0x3d0(%rbp,%rsi,4)
subl %edx, 0x450(%rbp,%rsi,4)
blsrl %ecx, %ecx
jmp 0x1e99b
cmpb $0x0, 0x21(%rbp)
jne 0x1e9c4
movl 0x50(%rbp), %ecx
movl %ecx, 0x58(%rbp)
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1e9fe
movzwl %ax, %ecx
leaq (%rcx,%rbp), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x150ab(%rip), %rdx     # 0x33a94
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
andnl 0x5c(%rbp), %ebx, %r13d
orl 0x70(%rbp), %r13d
andnl 0x60(%rbp), %ebx, %r14d
orl 0x74(%rbp), %r14d
leaq 0x7cb2(%rbp), %r15
xorl %r12d, %r12d
movl 0x64(%rbp), %ecx
orl %r13d, %ecx
lzcntl %ecx, %ecx
pushq $0x20
popq %rdx
subl %ecx, %edx
cmpq %rdx, %r12
jae 0x1eb95
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1ea6e
movzwl %ax, %edi
addq %r15, %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movl 0xfc(%rbp,%r12,4), %ecx
leaq 0x1504b(%rip), %rdx     # 0x33aa4
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
pushq $0x1
popq %rcx
shlxl %r12d, %ecx, %ebx
btl %r12d, %r13d
jae 0x1eace
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1eace
leaq 0x15029(%rip), %rdx     # 0x33ab2
testl %r14d, %ebx
leaq 0x1502a(%rip), %rcx     # 0x33abd
cmoveq %rcx, %rdx
je 0x1eaa4
movsbl 0x390(%rbp,%r12), %ecx
jmp 0x1eaa9
movl 0x7c(%rbp,%r12,4), %ecx
movzwl %ax, %edi
addq %r15, %rdi
movl $0x2542, %esi           # imm = 0x2542
subl %eax, %esi
movzwl %si, %esi
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
testl %ebx, 0x64(%rbp)
je 0x1eb1a
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1eb1a
movzwl %ax, %edi
addq %r15, %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movl 0x3d0(%rbp,%r12,4), %eax
movl 0x450(%rbp,%r12,4), %ecx
cmpl %ecx, %eax
cmovsl %eax, %ecx
leaq 0x14fc3(%rip), %rdx     # 0x33ac8
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
movl 0x78(%rbp), %ecx
testl %ecx, %ecx
je 0x1eb5b
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1eb8d
movzwl %ax, %edi
addq %r15, %rdi
movl $0x2542, %edx           # imm = 0x2542
subl %eax, %edx
movzwl %dx, %esi
shrxl %r12d, %ecx, %ecx
andl $0x1, %ecx
leaq 0x14f8c(%rip), %rdx     # 0x33ad2
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
cmpw $0x2541, %ax            # imm = 0x2541
ja 0x1eb8d
movzwl %ax, %edi
addq %r15, %rdi
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x15e29(%rip), %rdx     # 0x349a1
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbp), %ax
movw %ax, 0x7cb0(%rbp)
incq %r12
jmp 0x1ea1c
vmovups (%rbp), %ymm0
movq 0x8(%rsp), %r12
vmovups %ymm0, (%r12)
cmpb $0x0, 0x20(%rbp)
je 0x1ebce
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
addq $-0x2, %rdi
xorl %edx, %edx
vzeroupper
callq 0x1150
movq %rax, 0x8(%r12)
addq $0x2, %rax
movq %rax, (%rbp)
movq 0x20(%rsp), %r14
movb 0x8(%r14), %al
movb %al, 0x2a(%r12)
movb 0x12(%r14), %al
movb %al, 0x2b(%r12)
movzwl 0x4(%r14), %eax
movw %ax, 0x30(%r12)
movzwl 0x6(%r14), %eax
movw %ax, 0x32(%r12)
cmpb $0x0, 0x22b(%r12)
je 0x1ed0a
vmovdqa 0x230(%r12), %xmm0
vmovdqa 0x240(%r12), %xmm1
vmovdqa 0x250(%r12), %xmm2
vmovdqa 0x260(%r12), %xmm3
vptestnmb %xmm0, %xmm0, %k1
vmovdqu8 0x230(%r14), %xmm0 {%k1}
vmovdqa %xmm0, 0x230(%r12)
vptestnmb %xmm1, %xmm1, %k1
vmovdqu8 0x230(%r14), %xmm1 {%k1}
vmovdqa %xmm1, 0x240(%r12)
vptestnmb %xmm2, %xmm2, %k1
vmovdqu8 0x230(%r14), %xmm2 {%k1}
vmovdqa %xmm2, 0x250(%r12)
vptestnmb %xmm3, %xmm3, %k1
vmovdqu8 0x260(%r14), %xmm3 {%k1}
vmovdqa %xmm3, 0x260(%r12)
vmovdqa 0x270(%r12), %xmm0
vptestnmb %xmm0, %xmm0, %k1
vmovdqu8 0x260(%r14), %xmm0 {%k1}
vmovdqa %xmm0, 0x270(%r12)
vmovdqa 0x280(%r12), %xmm0
vptestnmb %xmm0, %xmm0, %k1
vmovdqu8 0x260(%r14), %xmm0 {%k1}
vmovdqa %xmm0, 0x280(%r12)
movl $0x290, %eax            # imm = 0x290
leaq (%r12,%rax), %rcx
addq %r14, %rax
xorl %edx, %edx
cmpq $0x18, %rdx
je 0x1ed54
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
jmp 0x1ecde
leaq 0x230(%r12), %rax
vmovdqu 0x230(%r14), %ymm0
vmovdqu 0x250(%r14), %ymm1
vmovdqu 0x270(%r14), %ymm2
vmovdqu %ymm2, 0x40(%rax)
vmovdqu %ymm1, 0x20(%rax)
vmovdqu %ymm0, (%rax)
movl $0x290, %esi            # imm = 0x290
leaq (%r12,%rsi), %rdi
addq %r14, %rsi
movl $0x180, %edx            # imm = 0x180
vzeroupper
callq 0x10c0
movl 0x24(%rbp), %ebx
movl 0x6c(%rbp), %eax
btl %ebx, %eax
setb 0x2e(%r12)
movl 0x512(%rbp), %eax
movl %eax, %ecx
shrl $0x10, %ecx
movw %cx, 0x38(%r12)
movl %eax, 0x34(%r12)
movq 0x2c(%rbp), %rax
movq %rax, 0x3c(%r12)
movsbq %bl, %rax
movl 0x48(%r12), %ecx
movb $-0x1, %dl
cmpl %ecx, 0x16d0(%rbp,%rax,4)
jne 0x1eda0
xorl %edx, %edx
cmpb $0x1, 0x21(%rbp)
sbbl %edx, %edx
orb %bl, %dl
movb %dl, 0x2d(%r12)
cmpl %ecx, 0x16d0(%rbp,%rax,4)
je 0x1edbb
movl $0x80000000, %edx       # imm = 0x80000000
cmpb $0x2, 0x27(%r12)
jne 0x1edbd
movl %ecx, %edx
movl %edx, 0x44(%r12)
movl 0x60(%rbp), %ecx
movl %ecx, 0x4c(%r12)
movq 0x188(%rbp,%rax,8), %rax
movq %rax, 0x58(%r12)
movb 0x1(%r14), %al
pushq $-0x1
popq %rcx
shlxl %eax, %ecx, %eax
notl %eax
vpbroadcastw %eax, %xmm0
vmovdqa %xmm0, 0x170(%r12)
movb 0x2(%r14), %al
shlxl %eax, %ecx, %eax
notl %eax
vpbroadcastw %eax, %xmm0
vmovdqa %xmm0, 0x190(%r12)
vmovdqa %xmm0, 0x180(%r12)
movq %rbp, %r14
movb 0x20(%r12), %bpl
cmpb $0x1, %bpl
jg 0x1efb1
leaq 0x188(%r14), %rsi
leaq 0x60(%r12), %rdi
movl $0x100, %edx            # imm = 0x100
vzeroupper
callq 0x10c0
cmpb $0x1, %bpl
jne 0x1efb1
cmpb $0x2, 0x225(%r12)
je 0x1ee66
cmpb $0x0, 0x24(%r12)
jne 0x1efb1
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(%r12)
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(%r12)
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(%r12)
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(%r12)
movq 0x78(%rsp), %rsi
pushq $0x1
popq %rax
shlxl %esi, %eax, %eax
vmovq 0x1648(%r14), %xmm0
vpbroadcastw %eax, %xmm1
vpor %xmm1, %xmm0, %xmm0
vmovd %xmm0, 0x1648(%r14)
vpbroadcastb 0x12621(%rip), %xmm0 # 0x31604
vpaddb 0x1a0(%r12), %xmm0, %xmm1
vpaddb 0x1c0(%r12), %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 0x121e1(%rip), %xmm1 # 0x31280
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 0x1f183
movzwl 0x7cb0(%rbx), %eax
cmpq $0x2541, %rax           # imm = 0x2541
ja 0x1f183
addq %rax, %r15
movl $0x2542, %ecx           # imm = 0x2542
subl %eax, %ecx
movzwl %cx, %esi
movq 0x70(%rsp), %rax
cmpb $0x0, (%rax)
leaq 0x1498f(%rip), %rax     # 0x33af3
leaq 0x14972(%rip), %rdx     # 0x33add
cmoveq %rax, %rdx
movq %r15, %rdi
xorl %eax, %eax
vzeroupper
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movq %rbx, %rdi
vzeroupper
callq 0x15361
pushq $0x5f
popq %rcx
movl %ecx, %r13d
testl %eax, %eax
jne 0x1f1be
cmpb $0x0, 0x20(%rbx)
je 0x1f1b2
addq $0x15b8, %rbx           # imm = 0x15B8
movq %rbx, %rdi
callq 0x10a0
xorl %r13d, %r13d
jmp 0x1f1be
movq %rbx, %rdi
callq *0x180(%rbx)
movq %rax, %r13
movl %r13d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movl %eax, 0xfc(%rbp,%rsi,4)
movl 0x50(%rbp), %eax
movl %eax, 0x3d0(%rbp,%rsi,4)
movl 0x54(%rbp), %eax
movl %eax, 0x450(%rbp,%rsi,4)
cmpq $0x0, 0x188(%rbp,%rsi,8)
jne 0x1d880
movq %rbp, %rdi
callq 0x1f58c
pushq $0xc
popq %rcx
movl %ecx, %r13d
testl %eax, %eax
jne 0x1f1be
jmp 0x1d880
decl %r8d
movsbl 0xf(%r14), %edx
movq (%rsp), %r11
movl 0x5c(%r11), %eax
movl 0x60(%r11), %esi
movl %esi, %ecx
movl 0x14(%rsp), %edi
andl %edi, %ecx
popcntl %ecx, %ecx
movl %edx, %r9d
subl %ecx, %r9d
cmpl %r9d, %r8d
cmovll %r8d, %r9d
movl %eax, %ecx
andl %edi, %ecx
popcntl %ecx, %ecx
subl %edx, %ecx
movl %r9d, 0x28(%rsp)
addl %r9d, %ecx
andnl %edi, %esi, %edx
testl %ecx, %ecx
jle 0x1f295
movl %edx, %edi
andl %eax, %edi
xorl %esi, %esi
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
testl %edi, %edi
je 0x1f28a
tzcntl %edi, %r9d
movl 0x7c(%r11,%r9,4), %r10d
cmpl %r8d, %r10d
cmovll %r10d, %r8d
cmovll %r9d, %esi
blsrl %edi, %edi
jmp 0x1f26a
btrl %esi, %eax
movl %eax, 0x5c(%r11)
decl %ecx
jmp 0x1f25a
movl 0x64(%r11), %ebx
movl %eax, %edx
orl %ebx, %edx
movl %edx, %ecx
movl 0x14(%rsp), %esi
andl %esi, %ecx
popcntl %ecx, %r8d
movq 0x20(%rsp), %rcx
movb 0x13(%rcx), %cl
movsbl %cl, %r14d
movl 0x28(%rsp), %edi
subl %r14d, %edi
addl %r8d, %edi
andnl %esi, %eax, %r8d
testl %edi, %edi
jle 0x1f31a
movl %r8d, %r11d
andl %ebx, %r11d
xorl %r10d, %r10d
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
testl %r11d, %r11d
je 0x1f2ff
tzcntl %r11d, %ebp
movq (%rsp), %rsi
movl 0x3d0(%rsi,%rbp,4), %esi
cmpl %r9d, %esi
cmovll %esi, %r9d
cmovll %ebp, %r10d
blsrl %r11d, %r11d
jmp 0x1f2d8
btrl %r10d, %ebx
movq (%rsp), %rsi
movl 0x58(%rsi), %r10d
cmpl %r9d, %r10d
cmovgl %r10d, %r9d
movl %r9d, 0x58(%rsi)
decl %edi
jmp 0x1f2c5
movq (%rsp), %rsi
movl 0x68(%rsi), %ebp
orl %ebp, %edx
andl 0x14(%rsp), %edx
popcntl %edx, %edx
addl 0x28(%rsp), %edx
cmpl %r14d, %edx
jg 0x1f1be
movq (%rsp), %rdx
movq 0x20(%rsp), %r14
orl %eax, %ebp
vmovdqa 0x1760(%rdx), %xmm0
vmovdqa 0x1780(%rdx), %xmm1
vpor 0x1750(%rdx), %xmm0, %xmm0
vpternlogd $0xfe, 0x1770(%rdx), %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
orl %ebx, %ebp
orl %eax, %ebp
andl 0x14(%rsp), %ebp
popcntl %ebp, %eax
addl 0x28(%rsp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jle 0x1f3bd
testl %r15d, %r15d
jne 0x1f3b5
movq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x1050
movq (%rsp), %rdx
movl 0x5c(%rdx), %eax
movl 0x68(%rdx), %ebp
movb 0x13(%r14), %cl
jmp 0x1f341
pushq $0xb
popq %rax
jmp 0x1d32e
movq (%rsp), %rax
movl 0x38(%rax), %ecx
movl %ecx, %r8d
movl 0x28(%rsp), %eax
subl %eax, %r8d
leal (%rcx,%rcx), %r9d
addl %eax, %eax
subl %eax, %r9d
movq (%rsp), %rbx
cmpl %ecx, %r8d
jae 0x1d468
andnl 0x14(%rsp), %ebp, %eax
tzcntl %eax, %esi
movq (%rsp), %rdi
movb %sil, 0x25(%rdi)
pushq $0x1
popq %rax
shlxl %esi, %eax, %eax
orl %eax, 0x5c(%rdi)
movl 0x78(%rdi), %eax
btrl %esi, %eax
xorl %edx, %edx
cmpb $0x14, 0x22(%rdi)
sete %dl
shlxl %esi, %edx, %edx
orl %eax, %edx
movl %edx, 0x78(%rdi)
movq 0x30(%rsp), %rax
movl %r8d, 0x3c(%rdi,%rax,4)
movl %r8d, 0x7c(%rdi,%rsi,4)
cmpb $0x2, 0xb(%r14)
movl %r9d, %edx
je 0x1f45e
movzbl 0xe(%r14), %r10d
testl %r10d, %r10d
je 0x1f45c
movl %r10d, %eax
movswl 0x28(%r14,%rax,2), %edi
movl %r8d, %eax
xorl %edx, %edx
divl %r10d
imull %edi, %eax
movswl 0x28(%r14,%rdx,2), %edx
addl %eax, %edx
jmp 0x1f45e
xorl %edx, %edx
movq (%rsp), %rax
movl %edx, 0x450(%rax,%rsi,4)
movl %edx, 0x3d0(%rax,%rsi,4)
cmpq $0x0, 0x188(%rax,%rsi,8)
jne 0x1f4a8
movl %r9d, 0x40(%rsp)
movl %r8d, 0x28(%rsp)
movq %rbx, %rdi
movq %rsi, 0x48(%rsp)
callq 0x1f58c
testl %eax, %eax
jne 0x1f4b7
movl 0x38(%rbx), %ecx
movl 0x28(%rsp), %r8d
movl 0x40(%rsp), %r9d
movq 0x48(%rsp), %rsi
btsl %esi, %ebp
incl %r8d
addl $0x2, %r9d
jmp 0x1f3db
pushq $0xc
jmp 0x1f3b7