// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/engine.c
// Function: dorotatesprite
static void dorotatesprite(int sx, int sy, int z, short a, short picnum, signed char dashade,
	unsigned char dapalnum, unsigned char dastat, int cx1, int cy1, int cx2, int cy2, int uniqid)
{
	int cosang, sinang, v, nextv, dax1, dax2, oy, bx, by;
	int x, y, x1, y1, x2, y2, gx1, gy1, iv;
	intptr_t i, p, bufplc, palookupoffs;
	int xsiz, ysiz, xoff, yoff, npoints, yplc, yinc, lx, rx;
	int xv, yv, xv2, yv2;

	//============================================================================= //POLYMOST BEGINS
#if USE_POLYMOST
	if (rendmode) { polymost_dorotatesprite(sx,sy,z,a,picnum,dashade,dapalnum,dastat,cx1,cy1,cx2,cy2,uniqid); return; }
#else
	(void)uniqid;
#endif
	//============================================================================= //POLYMOST ENDS

	if (cx1 < 0) cx1 = 0;
	if (cy1 < 0) cy1 = 0;
	if (cx2 > xres-1) cx2 = xres-1;
	if (cy2 > yres-1) cy2 = yres-1;

	xsiz = tilesizx[picnum]; ysiz = tilesizy[picnum];
	if (dastat&16) { xoff = 0; yoff = 0; }
	else
	{
		xoff = (int)((signed char)((picanm[picnum]>>8)&255))+(xsiz>>1);
		yoff = (int)((signed char)((picanm[picnum]>>16)&255))+(ysiz>>1);
	}

	if (dastat&4) yoff = ysiz-yoff;

	cosang = sintable[(a+512)&2047]; sinang = sintable[a&2047];

	if ((dastat&2) != 0)  //Auto window size scaling
	{
		if ((dastat&8) == 0)
		{
			if (widescreen) {
				x = ydimenscale;   //= scale(xdimen,yxaspect,320);
				sx = ((cx1+cx2+2)<<15)+scale(sx-(320<<15),ydimen<<16,200*pixelaspect);
			} else {
				x = xdimenscale;   //= scale(xdimen,yxaspect,320);
				sx = ((cx1+cx2+2)<<15)+scale(sx-(320<<15),xdimen,320);
			}
			sy = ((cy1+cy2+2)<<15)+mulscale16(sy-(200<<15),x);
		}
		else
		{
			  //If not clipping to startmosts, & auto-scaling on, as a
			  //hard-coded bonus, scale to full screen instead
			if (widescreen) {
				x = scale(ydim<<16,yxaspect,200*pixelaspect);
				sx = (xdim<<15)+32768+scale(sx-(320<<15),ydim<<16,200*pixelaspect);
			} else {
				x = scale(xdim,yxaspect,320);
				sx = (xdim<<15)+32768+scale(sx-(320<<15),xdim,320);
			}
			sy = (ydim<<15)+32768+mulscale16(sy-(200<<15),x);
		}
		z = mulscale16(z,x);
	}

	xv = mulscale14(cosang,z);
	yv = mulscale14(sinang,z);
	if (((dastat&2) != 0) || ((dastat&8) == 0)) //Don't aspect unscaled perms
	{
		xv2 = mulscale16(xv,xyaspect);
		yv2 = mulscale16(yv,xyaspect);
	}
	else
	{
		xv2 = xv;
		yv2 = yv;
	}

	nry1[0] = sy - (yv*xoff + xv*yoff);
	nry1[1] = nry1[0] + yv*xsiz;
	nry1[3] = nry1[0] + xv*ysiz;
	nry1[2] = nry1[1]+nry1[3]-nry1[0];
	i = (cy1<<16); if ((nry1[0]<i) && (nry1[1]<i) && (nry1[2]<i) && (nry1[3]<i)) return;
	i = (cy2<<16); if ((nry1[0]>i) && (nry1[1]>i) && (nry1[2]>i) && (nry1[3]>i)) return;

	nrx1[0] = sx - (xv2*xoff - yv2*yoff);
	nrx1[1] = nrx1[0] + xv2*xsiz;
	nrx1[3] = nrx1[0] - yv2*ysiz;
	nrx1[2] = nrx1[1]+nrx1[3]-nrx1[0];
	i = (cx1<<16); if ((nrx1[0]<i) && (nrx1[1]<i) && (nrx1[2]<i) && (nrx1[3]<i)) return;
	i = (cx2<<16); if ((nrx1[0]>i) && (nrx1[1]>i) && (nrx1[2]>i) && (nrx1[3]>i)) return;

	gx1 = nrx1[0]; gy1 = nry1[0];   //back up these before clipping

	if ((npoints = clippoly4(cx1<<16,cy1<<16,(cx2+1)<<16,(cy2+1)<<16)) < 3) return;

	lx = nrx1[0]; rx = nrx1[0];

	nextv = 0;
	for(v=npoints-1;v>=0;v--)
	{
		x1 = nrx1[v]; x2 = nrx1[nextv];
		dax1 = (x1>>16); if (x1 < lx) lx = x1;
		dax2 = (x2>>16); if (x1 > rx) rx = x1;
		if (dax1 != dax2)
		{
			y1 = nry1[v]; y2 = nry1[nextv];
			yinc = divscale16(y2-y1,x2-x1);
			if (dax2 > dax1)
			{
				yplc = y1 + mulscale16((dax1<<16)+65535-x1,yinc);
				qinterpolatedown16short(&uplc[dax1],dax2-dax1,yplc,yinc);
			}
			else
			{
				yplc = y2 + mulscale16((dax2<<16)+65535-x2,yinc);
				qinterpolatedown16short(&dplc[dax2],dax1-dax2,yplc,yinc);
			}
		}
		nextv = v;
	}

	if (waloff[picnum] == 0) loadtile(picnum);
	setgotpic(picnum);
	bufplc = waloff[picnum];

	palookupoffs = (intptr_t)palookup[dapalnum] + (getpalookup(0L,(int)dashade)<<8);

	iv = divscale32(1L,z);
	xv = mulscale14(sinang,iv);
	yv = mulscale14(cosang,iv);
	if (((dastat&2) != 0) || ((dastat&8) == 0)) //Don't aspect unscaled perms
	{
		yv2 = mulscale16(-xv,yxaspect);
		xv2 = mulscale16(yv,yxaspect);
	}
	else
	{
		yv2 = -xv;
		xv2 = yv;
	}

	x1 = (lx>>16); x2 = (rx>>16);

	oy = 0;
	x = (x1<<16)-1-gx1; y = (oy<<16)+65535-gy1;
	bx = dmulscale16(x,xv2,y,xv);
	by = dmulscale16(x,yv2,y,yv);
	if (dastat&4) { yv = -yv; yv2 = -yv2; by = (ysiz<<16)-1-by; }

#ifndef USING_A_C
	int ny1, ny2, xx, xend, qlinemode=0, y1ve[4], y2ve[4], u4, d4;
	char bad;

	if ((dastat&1) == 0)
	{
		if (((a&1023) == 0) && (ysiz <= 256))  //vlineasm4 has 256 high limit!
		{
			if (dastat&64) setupvlineasm(24L); else setupmvlineasm(24L);
			by <<= 8; yv <<= 8; yv2 <<= 8;

			palookupoffse[0] = palookupoffse[1] = palookupoffse[2] = palookupoffse[3] = palookupoffs;
			vince[0] = vince[1] = vince[2] = vince[3] = yv;

			for(x=x1;x<x2;x+=4)
			{
				bad = 15; xend = min(x2-x,4);
				for(xx=0;xx<xend;xx++)
				{
					bx += xv2;

					y1 = uplc[x+xx]; y2 = dplc[x+xx];
					if ((dastat&8) == 0)
					{
						if (startumost[x+xx] > y1) y1 = startumost[x+xx];
						if (startdmost[x+xx] < y2) y2 = startdmost[x+xx];
					}
					if (y2 <= y1) continue;

					by += yv*(y1-oy); oy = y1;

					bufplce[xx] = (bx>>16)*ysiz+bufplc;
					vplce[xx] = by;
					y1ve[xx] = y1;
					y2ve[xx] = y2-1;
					bad &= ~pow2char[xx];
				}

				p = x+frameplace;

				u4 = max(max(y1ve[0],y1ve[1]),max(y1ve[2],y1ve[3]));
				d4 = min(min(y2ve[0],y2ve[1]),min(y2ve[2],y2ve[3]));

				if (dastat&64)
				{
					if ((bad != 0) || (u4 >= d4))
					{
						if (!(bad&1)) prevlineasm1(vince[0],(void *)palookupoffse[0],y2ve[0]-y1ve[0],vplce[0],(void *)bufplce[0],(void *)(ylookup[y1ve[0]]+p+0));
						if (!(bad&2)) prevlineasm1(vince[1],(void *)palookupoffse[1],y2ve[1]-y1ve[1],vplce[1],(void *)bufplce[1],(void *)(ylookup[y1ve[1]]+p+1));
						if (!(bad&4)) prevlineasm1(vince[2],(void *)palookupoffse[2],y2ve[2]-y1ve[2],vplce[2],(void *)bufplce[2],(void *)(ylookup[y1ve[2]]+p+2));
						if (!(bad&8)) prevlineasm1(vince[3],(void *)palookupoffse[3],y2ve[3]-y1ve[3],vplce[3],(void *)bufplce[3],(void *)(ylookup[y1ve[3]]+p+3));
						continue;
					}

					if (u4 > y1ve[0]) vplce[0] = prevlineasm1(vince[0],(void *)palookupoffse[0],u4-y1ve[0]-1,vplce[0],(void *)bufplce[0],(void *)(ylookup[y1ve[0]]+p+0));
					if (u4 > y1ve[1]) vplce[1] = prevlineasm1(vince[1],(void *)palookupoffse[1],u4-y1ve[1]-1,vplce[1],(void *)bufplce[1],(void *)(ylookup[y1ve[1]]+p+1));
					if (u4 > y1ve[2]) vplce[2] = prevlineasm1(vince[2],(void *)palookupoffse[2],u4-y1ve[2]-1,vplce[2],(void *)bufplce[2],(void *)(ylookup[y1ve[2]]+p+2));
					if (u4 > y1ve[3]) vplce[3] = prevlineasm1(vince[3],(void *)palookupoffse[3],u4-y1ve[3]-1,vplce[3],(void *)bufplce[3],(void *)(ylookup[y1ve[3]]+p+3));

					if (d4 >= u4) vlineasm4(d4-u4+1,(void *)(ylookup[u4]+p));

					i = p+ylookup[d4+1];
					if (y2ve[0] > d4) prevlineasm1(vince[0],(void *)palookupoffse[0],y2ve[0]-d4-1,vplce[0],(void *)bufplce[0],(void *)(i+0));
					if (y2ve[1] > d4) prevlineasm1(vince[1],(void *)palookupoffse[1],y2ve[1]-d4-1,vplce[1],(void *)bufplce[1],(void *)(i+1));
					if (y2ve[2] > d4) prevlineasm1(vince[2],(void *)palookupoffse[2],y2ve[2]-d4-1,vplce[2],(void *)bufplce[2],(void *)(i+2));
					if (y2ve[3] > d4) prevlineasm1(vince[3],(void *)palookupoffse[3],y2ve[3]-d4-1,vplce[3],(void *)bufplce[3],(void *)(i+3));
				}
				else
				{
					if ((bad != 0) || (u4 >= d4))
					{
						if (!(bad&1)) mvlineasm1(vince[0],(void *)palookupoffse[0],y2ve[0]-y1ve[0],vplce[0],(void *)bufplce[0],(void *)(ylookup[y1ve[0]]+p+0));
						if (!(bad&2)) mvlineasm1(vince[1],(void *)palookupoffse[1],y2ve[1]-y1ve[1],vplce[1],(void *)bufplce[1],(void *)(ylookup[y1ve[1]]+p+1));
						if (!(bad&4)) mvlineasm1(vince[2],(void *)palookupoffse[2],y2ve[2]-y1ve[2],vplce[2],(void *)bufplce[2],(void *)(ylookup[y1ve[2]]+p+2));
						if (!(bad&8)) mvlineasm1(vince[3],(void *)palookupoffse[3],y2ve[3]-y1ve[3],vplce[3],(void *)bufplce[3],(void *)(ylookup[y1ve[3]]+p+3));
						continue;
					}

					if (u4 > y1ve[0]) vplce[0] = mvlineasm1(vince[0],(void *)palookupoffse[0],u4-y1ve[0]-1,vplce[0],(void *)bufplce[0],(void *)(ylookup[y1ve[0]]+p+0));
					if (u4 > y1ve[1]) vplce[1] = mvlineasm1(vince[1],(void *)palookupoffse[1],u4-y1ve[1]-1,vplce[1],(void *)bufplce[1],(void *)(ylookup[y1ve[1]]+p+1));
					if (u4 > y1ve[2]) vplce[2] = mvlineasm1(vince[2],(void *)palookupoffse[2],u4-y1ve[2]-1,vplce[2],(void *)bufplce[2],(void *)(ylookup[y1ve[2]]+p+2));
					if (u4 > y1ve[3]) vplce[3] = mvlineasm1(vince[3],(void *)palookupoffse[3],u4-y1ve[3]-1,vplce[3],(void *)bufplce[3],(void *)(ylookup[y1ve[3]]+p+3));

					if (d4 >= u4) mvlineasm4(d4-u4+1,(void *)(ylookup[u4]+p));

					i = p+ylookup[d4+1];
					if (y2ve[0] > d4) mvlineasm1(vince[0],(void *)palookupoffse[0],y2ve[0]-d4-1,vplce[0],(void *)bufplce[0],(void *)(i+0));
					if (y2ve[1] > d4) mvlineasm1(vince[1],(void *)palookupoffse[1],y2ve[1]-d4-1,vplce[1],(void *)bufplce[1],(void *)(i+1));
					if (y2ve[2] > d4) mvlineasm1(vince[2],(void *)palookupoffse[2],y2ve[2]-d4-1,vplce[2],(void *)bufplce[2],(void *)(i+2));
					if (y2ve[3] > d4) mvlineasm1(vince[3],(void *)palookupoffse[3],y2ve[3]-d4-1,vplce[3],(void *)bufplce[3],(void *)(i+3));
				}

				faketimerhandler();
			}
		}
		else
		{
			if (dastat&64)
			{
				if ((xv2&0x0000ffff) == 0)
				{
					qlinemode = 1;
					setupqrhlineasm4(0L,yv2<<16,(xv2>>16)*ysiz+(yv2>>16),(void *)palookupoffs,0L,0L);
				}
				else
				{
					qlinemode = 0;
					setuprhlineasm4(xv2<<16,yv2<<16,(xv2>>16)*ysiz+(yv2>>16),(void *)palookupoffs,ysiz,0L);
				}
			}
			else
				setuprmhlineasm4(xv2<<16,yv2<<16,(xv2>>16)*ysiz+(yv2>>16),(void *)palookupoffs,ysiz,0L);

			y1 = uplc[x1];
			if (((dastat&8) == 0) && (startumost[x1] > y1)) y1 = startumost[x1];
			y2 = y1;
			for(x=x1;x<x2;x++)
			{
				ny1 = uplc[x]-1; ny2 = dplc[x];
				if ((dastat&8) == 0)
				{
					if (startumost[x]-1 > ny1) ny1 = startumost[x]-1;
					if (startdmost[x] < ny2) ny2 = startdmost[x];
				}

				if (ny1 < ny2-1)
				{
					if (ny1 >= y2)
					{
						while (y1 < y2-1)
						{
							y1++; if ((y1&31) == 0) faketimerhandler();

								//x,y1
							bx += xv*(y1-oy); by += yv*(y1-oy); oy = y1;
							if (dastat&64) {
								if (qlinemode) qrhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,0L    ,by<<16,(void *)(ylookup[y1]+x+frameplace));
								else rhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x+frameplace));
							} else rmhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x+frameplace));
						}
						y1 = ny1;
					}
					else
					{
						while (y1 < ny1)
						{
							y1++; if ((y1&31) == 0) faketimerhandler();

								//x,y1
							bx += xv*(y1-oy); by += yv*(y1-oy); oy = y1;
							if (dastat&64) {
								if (qlinemode) qrhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,0L    ,by<<16,(void *)(ylookup[y1]+x+frameplace));
								else rhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x+frameplace));
							} else rmhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x+frameplace));
						}
						while (y1 > ny1) lastx[y1--] = x;
					}
					while (y2 > ny2)
					{
						y2--; if ((y2&31) == 0) faketimerhandler();

							//x,y2
						bx += xv*(y2-oy); by += yv*(y2-oy); oy = y2;
						if (dastat&64) {
							if (qlinemode) qrhlineasm4(x-lastx[y2],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,0L    ,by<<16,(void *)(ylookup[y2]+x+frameplace));
							else rhlineasm4(x-lastx[y2],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y2]+x+frameplace));
						} else rmhlineasm4(x-lastx[y2],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y2]+x+frameplace));
					}
					while (y2 < ny2) lastx[y2++] = x;
				}
				else
				{
					while (y1 < y2-1)
					{
						y1++; if ((y1&31) == 0) faketimerhandler();

							//x,y1
						bx += xv*(y1-oy); by += yv*(y1-oy); oy = y1;
						if (dastat&64) {
							if (qlinemode) qrhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,0L    ,by<<16,(void *)(ylookup[y1]+x+frameplace));
							else rhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x+frameplace));
						} else rmhlineasm4(x-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x+frameplace));
					}
					if (x == x2-1) { bx += xv2; by += yv2; break; }
					y1 = uplc[x+1];
					if (((dastat&8) == 0) && (startumost[x+1] > y1)) y1 = startumost[x+1];
					y2 = y1;
				}
				bx += xv2; by += yv2;
			}
			while (y1 < y2-1)
			{
				y1++; if ((y1&31) == 0) faketimerhandler();

					//x2,y1
				bx += xv*(y1-oy); by += yv*(y1-oy); oy = y1;
				if (dastat&64) {
					if (qlinemode) qrhlineasm4(x2-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,0L,by<<16,(void *)(ylookup[y1]+x2+frameplace));
					else rhlineasm4(x2-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x2+frameplace));
				} else rmhlineasm4(x2-lastx[y1],(void *)((bx>>16)*ysiz+(by>>16)+bufplc),0L,bx<<16,by<<16,(void *)(ylookup[y1]+x2+frameplace));
			}
		}
	}
	else
	{
		if ((dastat&1) == 0)
		{
			if (dastat&64)
				setupspritevline((void *)palookupoffs,(xv>>16)*ysiz,xv<<16,ysiz,yv,0L);
			else
				msetupspritevline((void *)palookupoffs,(xv>>16)*ysiz,xv<<16,ysiz,yv,0L);
		}
		else
		{
			tsetupspritevline((void *)palookupoffs,(xv>>16)*ysiz,xv<<16,ysiz,yv,0L);
			if (dastat&32) settransreverse(); else settransnormal();
		}
		for(x=x1;x<x2;x++)
		{
			bx += xv2; by += yv2;

			y1 = uplc[x]; y2 = dplc[x];
			if ((dastat&8) == 0)
			{
				if (startumost[x] > y1) y1 = startumost[x];
				if (startdmost[x] < y2) y2 = startdmost[x];
			}
			if (y2 <= y1) continue;

			switch(y1-oy)
			{
				case -1: bx -= xv; by -= yv; oy = y1; break;
				case 0: break;
				case 1: bx += xv; by += yv; oy = y1; break;
				default: bx += xv*(y1-oy); by += yv*(y1-oy); oy = y1; break;
			}

			p = ylookup[y1]+x+frameplace;

			if ((dastat&1) == 0)
			{
				if (dastat&64)
					spritevline(0L,by<<16,y2-y1+1,bx<<16,(void *)((bx>>16)*ysiz+(by>>16)+bufplc),(void *)p);
				else
					mspritevline(0L,by<<16,y2-y1+1,bx<<16,(void *)((bx>>16)*ysiz+(by>>16)+bufplc),(void *)p);
			}
			else
			{
				tspritevline(0L,by<<16,y2-y1+1,bx<<16,(void *)((bx>>16)*ysiz+(by>>16)+bufplc),(void *)p);
			}
			faketimerhandler();
		}
	}

#else	// USING_A_C

	if ((dastat&1) == 0)
	{
		if (dastat&64)
			setupspritevline((void *)palookupoffs,xv,yv,ysiz);
		else
			msetupspritevline((void *)palookupoffs,xv,yv,ysiz);
	}
	else
	{
		tsetupspritevline((void *)palookupoffs,xv,yv,ysiz);
		if (dastat&32) settransreverse(); else settransnormal();
	}
	for(x=x1;x<x2;x++)
	{
		bx += xv2; by += yv2;

		y1 = uplc[x]; y2 = dplc[x];
		if ((dastat&8) == 0)
		{
			if (startumost[x] > y1) y1 = startumost[x];
			if (startdmost[x] < y2) y2 = startdmost[x];
		}
		if (y2 <= y1) continue;

		switch(y1-oy)
		{
			case -1: bx -= xv; by -= yv; oy = y1; break;
			case 0: break;
			case 1: bx += xv; by += yv; oy = y1; break;
			default: bx += xv*(y1-oy); by += yv*(y1-oy); oy = y1; break;
		}

		p = ylookup[y1]+x+frameplace;

		if ((dastat&1) == 0)
		{
			if (dastat&64)
				spritevline(bx&65535,by&65535,y2-y1+1,(void *)((bx>>16)*ysiz+(by>>16)+bufplc),(void *)p);
			else
				mspritevline(bx&65535,by&65535,y2-y1+1,(void *)((bx>>16)*ysiz+(by>>16)+bufplc),(void *)p);
		}
		else
		{
			tspritevline(bx&65535,by&65535,y2-y1+1,(void *)((bx>>16)*ysiz+(by>>16)+bufplc),(void *)p);
			//transarea += (y2-y1);
		}
		faketimerhandler();
	}

#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movl %r8d, -0xe4(%rbp)
movl %ecx, %eax
movl -0xe4(%rbp), %ecx
movl %eax, -0xe0(%rbp)
movl %edx, %eax
movl -0xe0(%rbp), %edx
movl %eax, -0xdc(%rbp)
movl %esi, %eax
movl -0xdc(%rbp), %esi
movl %eax, -0xd8(%rbp)
movl %edi, %r8d
movl -0xd8(%rbp), %edi
movb %r9b, %al
movl 0x40(%rbp), %r9d
movl 0x38(%rbp), %r9d
movl 0x30(%rbp), %r9d
movl 0x28(%rbp), %r9d
movl 0x20(%rbp), %r9d
movb 0x18(%rbp), %r9b
movb 0x10(%rbp), %r9b
movl %r8d, -0x24(%rbp)
movl %edi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movw %dx, -0x2e(%rbp)
movw %cx, -0x30(%rbp)
movb %al, -0x31(%rbp)
leaq 0x5a06a9(%rip), %rax    # 0x5ed920
cmpl $0x0, (%rax)
je 0x4d2e9
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
movw -0x2e(%rbp), %cx
movw -0x30(%rbp), %r8w
movb -0x31(%rbp), %r9b
movb 0x10(%rbp), %r12b
movb 0x18(%rbp), %r15b
movl 0x20(%rbp), %r14d
movl 0x28(%rbp), %ebx
movl 0x30(%rbp), %r11d
movl 0x38(%rbp), %r10d
movl 0x40(%rbp), %eax
movswl %cx, %ecx
movswl %r8w, %r8d
movsbl %r9b, %r9d
movzbl %r12b, %r12d
movl %r12d, (%rsp)
movzbl %r15b, %r15d
movl %r15d, 0x8(%rsp)
movl %r14d, 0x10(%rsp)
movl %ebx, 0x18(%rsp)
movl %r11d, 0x20(%rsp)
movl %r10d, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x86e20
jmp 0x4dfa5
cmpl $0x0, 0x20(%rbp)
jge 0x4d2f6
movl $0x0, 0x20(%rbp)
cmpl $0x0, 0x28(%rbp)
jge 0x4d303
movl $0x0, 0x28(%rbp)
movl 0x30(%rbp), %eax
leaq 0x930e7(%rip), %rcx     # 0xe03f4
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x4d325
leaq 0x930d7(%rip), %rax     # 0xe03f4
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x30(%rbp)
movl 0x38(%rbp), %eax
leaq 0x930c9(%rip), %rcx     # 0xe03f8
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x4d347
leaq 0x930b9(%rip), %rax     # 0xe03f8
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x38(%rbp)
movswq -0x30(%rbp), %rcx
leaq 0x3fda2d(%rip), %rax    # 0x44ad80
movswl (%rax,%rcx,2), %eax
movl %eax, -0xa4(%rbp)
movswq -0x30(%rbp), %rcx
leaq 0x3ef1d7(%rip), %rax    # 0x43c540
movswl (%rax,%rcx,2), %eax
movl %eax, -0xa8(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4d395
movl $0x0, -0xac(%rbp)
movl $0x0, -0xb0(%rbp)
jmp 0x4d3e9
movswq -0x30(%rbp), %rcx
leaq 0x22a21f(%rip), %rax    # 0x2775c0
movl (%rax,%rcx,4), %eax
sarl $0x8, %eax
andl $0xff, %eax
movsbl %al, %eax
movl -0xa4(%rbp), %ecx
sarl %ecx
addl %ecx, %eax
movl %eax, -0xac(%rbp)
movswq -0x30(%rbp), %rcx
leaq 0x22a1f5(%rip), %rax    # 0x2775c0
movl (%rax,%rcx,4), %eax
sarl $0x10, %eax
andl $0xff, %eax
movsbl %al, %eax
movl -0xa8(%rbp), %ecx
sarl %ecx
addl %ecx, %eax
movl %eax, -0xb0(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4d407
movl -0xa8(%rbp), %eax
subl -0xb0(%rbp), %eax
movl %eax, -0xb0(%rbp)
movswl -0x2e(%rbp), %eax
addl $0x200, %eax            # imm = 0x200
andl $0x7ff, %eax            # imm = 0x7FF
movslq %eax, %rcx
leaq 0x3be491(%rip), %rax    # 0x40b8b0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x38(%rbp)
movswl -0x2e(%rbp), %eax
andl $0x7ff, %eax            # imm = 0x7FF
movslq %eax, %rcx
leaq 0x3be477(%rip), %rax    # 0x40b8b0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x3c(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4d62b
movzbl 0x18(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x4d52a
cmpl $0x0, 0x4045e9(%rip)    # 0x451a50
je 0x4d4b4
movl 0x423981(%rip), %eax    # 0x470df0
movl %eax, -0x5c(%rbp)
movl 0x20(%rbp), %eax
addl 0x30(%rbp), %eax
addl $0x2, %eax
shll $0xf, %eax
movl %eax, -0xe8(%rbp)
movl -0x24(%rbp), %edi
subl $0xa00000, %edi         # imm = 0xA00000
movl 0x26b161(%rip), %esi    # 0x2b85f4
shll $0x10, %esi
imull $0xc8, 0x4045b8(%rip), %edx # 0x451a58
callq 0x37720
movl %eax, %ecx
movl -0xe8(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x4d4f5
movl 0x26b13e(%rip), %eax    # 0x2b85f8
movl %eax, -0x5c(%rbp)
movl 0x20(%rbp), %eax
addl 0x30(%rbp), %eax
addl $0x2, %eax
shll $0xf, %eax
movl %eax, -0xec(%rbp)
movl -0x24(%rbp), %edi
subl $0xa00000, %edi         # imm = 0xA00000
movl 0x93842(%rip), %esi     # 0xe0d20
movl $0x140, %edx            # imm = 0x140
callq 0x37720
movl %eax, %ecx
movl -0xec(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl 0x28(%rbp), %eax
addl 0x38(%rbp), %eax
addl $0x2, %eax
shll $0xf, %eax
movl %eax, -0xf0(%rbp)
movl -0x28(%rbp), %edi
subl $0x640000, %edi         # imm = 0x640000
movl -0x5c(%rbp), %esi
callq 0x39010
movl %eax, %ecx
movl -0xf0(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0x4d61d
cmpl $0x0, 0x40451f(%rip)    # 0x451a50
je 0x4d598
movl 0x3f5817(%rip), %edi    # 0x442d50
shll $0x10, %edi
movl 0x3f5806(%rip), %esi    # 0x442d48
imull $0xc8, 0x40450c(%rip), %edx # 0x451a58
callq 0x37720
movl %eax, -0x5c(%rbp)
movl 0x3f57f2(%rip), %eax    # 0x442d4c
shll $0xf, %eax
addl $0x8000, %eax           # imm = 0x8000
movl %eax, -0xf4(%rbp)
movl -0x24(%rbp), %edi
subl $0xa00000, %edi         # imm = 0xA00000
movl 0x3f57d9(%rip), %esi    # 0x442d50
shll $0x10, %esi
imull $0xc8, 0x4044d4(%rip), %edx # 0x451a58
callq 0x37720
movl %eax, %ecx
movl -0xf4(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x4d5eb
movl 0x3f57ae(%rip), %edi    # 0x442d4c
movl 0x3f57a4(%rip), %esi    # 0x442d48
movl $0x140, %edx            # imm = 0x140
callq 0x37720
movl %eax, -0x5c(%rbp)
movl 0x3f5795(%rip), %eax    # 0x442d4c
shll $0xf, %eax
addl $0x8000, %eax           # imm = 0x8000
movl %eax, -0xf8(%rbp)
movl -0x24(%rbp), %edi
subl $0xa00000, %edi         # imm = 0xA00000
movl 0x3f5778(%rip), %esi    # 0x442d4c
movl $0x140, %edx            # imm = 0x140
callq 0x37720
movl %eax, %ecx
movl -0xf8(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl 0x3f575f(%rip), %eax    # 0x442d50
shll $0xf, %eax
addl $0x8000, %eax           # imm = 0x8000
movl %eax, -0xfc(%rbp)
movl -0x28(%rbp), %edi
subl $0x640000, %edi         # imm = 0x640000
movl -0x5c(%rbp), %esi
callq 0x39010
movl %eax, %ecx
movl -0xfc(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %edi
movl -0x5c(%rbp), %esi
callq 0x39010
movl %eax, -0x2c(%rbp)
movl -0x38(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x52680
movl %eax, -0xc8(%rbp)
movl -0x3c(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x52680
movl %eax, -0xcc(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x4d665
movzbl 0x18(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x4d695
movl -0xc8(%rbp), %edi
movl 0x34cda7(%rip), %esi    # 0x39a418
callq 0x39010
movl %eax, -0xd0(%rbp)
movl -0xcc(%rbp), %edi
movl 0x34cd90(%rip), %esi    # 0x39a418
callq 0x39010
movl %eax, -0xd4(%rbp)
jmp 0x4d6ad
movl -0xc8(%rbp), %eax
movl %eax, -0xd0(%rbp)
movl -0xcc(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0x28(%rbp), %eax
movl -0xcc(%rbp), %ecx
imull -0xac(%rbp), %ecx
movl -0xc8(%rbp), %edx
imull -0xb0(%rbp), %edx
addl %edx, %ecx
subl %ecx, %eax
movl %eax, 0x55b3ec(%rip)    # 0x5a8ac0
movl 0x55b3e6(%rip), %eax    # 0x5a8ac0
movl -0xcc(%rbp), %ecx
imull -0xa4(%rbp), %ecx
addl %ecx, %eax
movl %eax, 0x55b3d5(%rip)    # 0x5a8ac4
movl 0x55b3cb(%rip), %eax    # 0x5a8ac0
movl -0xc8(%rbp), %ecx
imull -0xa8(%rbp), %ecx
addl %ecx, %eax
movl %eax, 0x55b3c2(%rip)    # 0x5a8acc
movl 0x55b3b4(%rip), %eax    # 0x5a8ac4
addl 0x55b3b6(%rip), %eax    # 0x5a8acc
subl 0x55b3a4(%rip), %eax    # 0x5a8ac0
movl %eax, 0x55b3a6(%rip)    # 0x5a8ac8
movl 0x28(%rbp), %eax
shll $0x10, %eax
cltq
movq %rax, -0x88(%rbp)
movslq 0x55b388(%rip), %rax    # 0x5a8ac0
cmpq -0x88(%rbp), %rax
jge 0x4d776
movslq 0x55b37c(%rip), %rax    # 0x5a8ac4
cmpq -0x88(%rbp), %rax
jge 0x4d776
movslq 0x55b370(%rip), %rax    # 0x5a8ac8
cmpq -0x88(%rbp), %rax
jge 0x4d776
movslq 0x55b364(%rip), %rax    # 0x5a8acc
cmpq -0x88(%rbp), %rax
jge 0x4d776
jmp 0x4dfa5
movl 0x38(%rbp), %eax
shll $0x10, %eax
cltq
movq %rax, -0x88(%rbp)
movslq 0x55b334(%rip), %rax    # 0x5a8ac0
cmpq -0x88(%rbp), %rax
jle 0x4d7ca
movslq 0x55b328(%rip), %rax    # 0x5a8ac4
cmpq -0x88(%rbp), %rax
jle 0x4d7ca
movslq 0x55b31c(%rip), %rax    # 0x5a8ac8
cmpq -0x88(%rbp), %rax
jle 0x4d7ca
movslq 0x55b310(%rip), %rax    # 0x5a8acc
cmpq -0x88(%rbp), %rax
jle 0x4d7ca
jmp 0x4dfa5
movl -0x24(%rbp), %eax
movl -0xd0(%rbp), %ecx
imull -0xac(%rbp), %ecx
movl -0xd4(%rbp), %edx
imull -0xb0(%rbp), %edx
subl %edx, %ecx
subl %ecx, %eax
movl %eax, 0x55b2ef(%rip)    # 0x5a8ae0
movl 0x55b2e9(%rip), %eax    # 0x5a8ae0
movl -0xd0(%rbp), %ecx
imull -0xa4(%rbp), %ecx
addl %ecx, %eax
movl %eax, 0x55b2d8(%rip)    # 0x5a8ae4
movl 0x55b2ce(%rip), %eax    # 0x5a8ae0
movl -0xd4(%rbp), %ecx
imull -0xa8(%rbp), %ecx
subl %ecx, %eax
movl %eax, 0x55b2c5(%rip)    # 0x5a8aec
movl 0x55b2b7(%rip), %eax    # 0x5a8ae4
addl 0x55b2b9(%rip), %eax    # 0x5a8aec
subl 0x55b2a7(%rip), %eax    # 0x5a8ae0
movl %eax, 0x55b2a9(%rip)    # 0x5a8ae8
movl 0x20(%rbp), %eax
shll $0x10, %eax
cltq
movq %rax, -0x88(%rbp)
movslq 0x55b28b(%rip), %rax    # 0x5a8ae0
cmpq -0x88(%rbp), %rax
jge 0x4d893
movslq 0x55b27f(%rip), %rax    # 0x5a8ae4
cmpq -0x88(%rbp), %rax
jge 0x4d893
movslq 0x55b273(%rip), %rax    # 0x5a8ae8
cmpq -0x88(%rbp), %rax
jge 0x4d893
movslq 0x55b267(%rip), %rax    # 0x5a8aec
cmpq -0x88(%rbp), %rax
jge 0x4d893
jmp 0x4dfa5
movl 0x30(%rbp), %eax
shll $0x10, %eax
cltq
movq %rax, -0x88(%rbp)
movslq 0x55b237(%rip), %rax    # 0x5a8ae0
cmpq -0x88(%rbp), %rax
jle 0x4d8e7
movslq 0x55b22b(%rip), %rax    # 0x5a8ae4
cmpq -0x88(%rbp), %rax
jle 0x4d8e7
movslq 0x55b21f(%rip), %rax    # 0x5a8ae8
cmpq -0x88(%rbp), %rax
jle 0x4d8e7
movslq 0x55b213(%rip), %rax    # 0x5a8aec
cmpq -0x88(%rbp), %rax
jle 0x4d8e7
jmp 0x4dfa5
movl 0x55b1f3(%rip), %eax    # 0x5a8ae0
movl %eax, -0x74(%rbp)
movl 0x55b1ca(%rip), %eax    # 0x5a8ac0
movl %eax, -0x78(%rbp)
movl 0x20(%rbp), %edi
shll $0x10, %edi
movl 0x28(%rbp), %esi
shll $0x10, %esi
movl 0x30(%rbp), %edx
addl $0x1, %edx
shll $0x10, %edx
movl 0x38(%rbp), %ecx
addl $0x1, %ecx
shll $0x10, %ecx
callq 0x60fc0
movl %eax, -0xb4(%rbp)
cmpl $0x3, %eax
jge 0x4d92c
jmp 0x4dfa5
movl 0x55b1ae(%rip), %eax    # 0x5a8ae0
movl %eax, -0xc0(%rbp)
movl 0x55b1a2(%rip), %eax    # 0x5a8ae0
movl %eax, -0xc4(%rbp)
movl $0x0, -0x44(%rbp)
movl -0xb4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jl 0x4dad8
movslq -0x40(%rbp), %rcx
leaq 0x55b174(%rip), %rax    # 0x5a8ae0
movl (%rax,%rcx,4), %eax
movl %eax, -0x64(%rbp)
movslq -0x44(%rbp), %rcx
leaq 0x55b163(%rip), %rax    # 0x5a8ae0
movl (%rax,%rcx,4), %eax
movl %eax, -0x6c(%rbp)
movl -0x64(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x48(%rbp)
movl -0x64(%rbp), %eax
cmpl -0xc0(%rbp), %eax
jge 0x4d9a0
movl -0x64(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0x6c(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x4c(%rbp)
movl -0x64(%rbp), %eax
cmpl -0xc4(%rbp), %eax
jle 0x4d9bd
movl -0x64(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x4c(%rbp), %eax
je 0x4dac4
movslq -0x40(%rbp), %rcx
leaq 0x55b0ec(%rip), %rax    # 0x5a8ac0
movl (%rax,%rcx,4), %eax
movl %eax, -0x68(%rbp)
movslq -0x44(%rbp), %rcx
leaq 0x55b0db(%rip), %rax    # 0x5a8ac0
movl (%rax,%rcx,4), %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %edi
subl -0x68(%rbp), %edi
movl -0x6c(%rbp), %esi
subl -0x64(%rbp), %esi
callq 0x4c7c0
movl %eax, -0xbc(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x48(%rbp), %eax
jle 0x4da67
movl -0x68(%rbp), %eax
movl %eax, -0x100(%rbp)
movl -0x48(%rbp), %edi
shll $0x10, %edi
addl $0xffff, %edi           # imm = 0xFFFF
subl -0x64(%rbp), %edi
movl -0xbc(%rbp), %esi
callq 0x39010
movl %eax, %ecx
movl -0x100(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xb8(%rbp)
movslq -0x48(%rbp), %rax
leaq 0x438188(%rip), %rdi    # 0x485bd0
shlq %rax
addq %rax, %rdi
movl -0x4c(%rbp), %esi
subl -0x48(%rbp), %esi
movl -0xb8(%rbp), %edx
movl -0xbc(%rbp), %ecx
callq 0x6ecf0
jmp 0x4dac2
movl -0x70(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x4c(%rbp), %edi
shll $0x10, %edi
addl $0xffff, %edi           # imm = 0xFFFF
subl -0x6c(%rbp), %edi
movl -0xbc(%rbp), %esi
callq 0x39010
movl %eax, %ecx
movl -0x104(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xb8(%rbp)
movslq -0x4c(%rbp), %rax
leaq 0x4397ab(%rip), %rdi    # 0x487250
shlq %rax
addq %rax, %rdi
movl -0x48(%rbp), %esi
subl -0x4c(%rbp), %esi
movl -0xb8(%rbp), %edx
movl -0xbc(%rbp), %ecx
callq 0x6ecf0
jmp 0x4dac4
movl -0x40(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x4d957
movswq -0x30(%rbp), %rcx
leaq 0x38835c(%rip), %rax    # 0x3d5e40
cmpq $0x0, (%rax,%rcx,8)
jne 0x4daf4
movswl -0x30(%rbp), %edi
callq 0x44df0
movswl -0x30(%rbp), %edi
callq 0x44d80
movswq -0x30(%rbp), %rcx
leaq 0x388337(%rip), %rax    # 0x3d5e40
movq (%rax,%rcx,8), %rax
movq %rax, -0x98(%rbp)
movzbl 0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x387b1f(%rip), %rax    # 0x3d5640
movq (%rax,%rcx,8), %rax
movq %rax, -0x110(%rbp)
movsbl -0x31(%rbp), %esi
xorl %edi, %edi
callq 0x5ec70
movl %eax, %ecx
movq -0x110(%rbp), %rax
shll $0x8, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xa0(%rbp)
movl -0x2c(%rbp), %esi
movl $0x1, %edi
callq 0x56e00
movl %eax, -0x7c(%rbp)
movl -0x3c(%rbp), %edi
movl -0x7c(%rbp), %esi
callq 0x52680
movl %eax, -0xc8(%rbp)
movl -0x38(%rbp), %edi
movl -0x7c(%rbp), %esi
callq 0x52680
movl %eax, -0xcc(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x4db9a
movzbl 0x18(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x4dbcc
xorl %edi, %edi
subl -0xc8(%rbp), %edi
movl 0x3f51a0(%rip), %esi    # 0x442d48
callq 0x39010
movl %eax, -0xd4(%rbp)
movl -0xcc(%rbp), %edi
movl 0x3f5189(%rip), %esi    # 0x442d48
callq 0x39010
movl %eax, -0xd0(%rbp)
jmp 0x4dbe6
xorl %eax, %eax
subl -0xc8(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xcc(%rbp), %eax
movl %eax, -0xd0(%rbp)
movl -0xc0(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x64(%rbp)
movl -0xc4(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x6c(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x64(%rbp), %eax
shll $0x10, %eax
subl $0x1, %eax
subl -0x74(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x50(%rbp), %eax
shll $0x10, %eax
addl $0xffff, %eax           # imm = 0xFFFF
subl -0x78(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edi
movl -0xd0(%rbp), %esi
movl -0x60(%rbp), %edx
movl -0xc8(%rbp), %ecx
callq 0x43950
movl %eax, -0x54(%rbp)
movl -0x5c(%rbp), %edi
movl -0xd4(%rbp), %esi
movl -0x60(%rbp), %edx
movl -0xcc(%rbp), %ecx
callq 0x43950
movl %eax, -0x58(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4dc93
xorl %eax, %eax
subl -0xcc(%rbp), %eax
movl %eax, -0xcc(%rbp)
xorl %eax, %eax
subl -0xd4(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xa8(%rbp), %eax
shll $0x10, %eax
subl $0x1, %eax
subl -0x58(%rbp), %eax
movl %eax, -0x58(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4dceb
movzbl 0x18(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4dccb
movq -0xa0(%rbp), %rdi
movl -0xc8(%rbp), %esi
movl -0xcc(%rbp), %edx
movl -0xa8(%rbp), %ecx
callq 0xa7ea0
jmp 0x4dce9
movq -0xa0(%rbp), %rdi
movl -0xc8(%rbp), %esi
movl -0xcc(%rbp), %edx
movl -0xa8(%rbp), %ecx
callq 0xa7f80
jmp 0x4dd23
movq -0xa0(%rbp), %rdi
movl -0xc8(%rbp), %esi
movl -0xcc(%rbp), %edx
movl -0xa8(%rbp), %ecx
callq 0xa8070
movzbl 0x18(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4dd1c
callq 0xa75a0
jmp 0x4dd21
callq 0xa7590
jmp 0x4dd23
movl -0x64(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jge 0x4dfa5
movl -0xd0(%rbp), %eax
addl -0x54(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0xd4(%rbp), %eax
addl -0x58(%rbp), %eax
movl %eax, -0x58(%rbp)
movslq -0x5c(%rbp), %rcx
leaq 0x437e78(%rip), %rax    # 0x485bd0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x68(%rbp)
movslq -0x5c(%rbp), %rcx
leaq 0x4394e6(%rip), %rax    # 0x487250
movswl (%rax,%rcx,2), %eax
movl %eax, -0x70(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x4ddcb
movslq -0x5c(%rbp), %rcx
leaq 0x3bed48(%rip), %rax    # 0x40cad0
movswl (%rax,%rcx,2), %eax
cmpl -0x68(%rbp), %eax
jle 0x4dda3
movslq -0x5c(%rbp), %rcx
leaq 0x3bed34(%rip), %rax    # 0x40cad0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x68(%rbp)
movslq -0x5c(%rbp), %rcx
leaq 0x3c03b2(%rip), %rax    # 0x40e160
movswl (%rax,%rcx,2), %eax
cmpl -0x70(%rbp), %eax
jge 0x4ddc9
movslq -0x5c(%rbp), %rcx
leaq 0x3c039e(%rip), %rax    # 0x40e160
movswl (%rax,%rcx,2), %eax
movl %eax, -0x70(%rbp)
jmp 0x4ddcb
movl -0x70(%rbp), %eax
cmpl -0x68(%rbp), %eax
jg 0x4ddd8
jmp 0x4df97
movl -0x68(%rbp), %eax
movl -0x50(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x114(%rbp)
subl $-0x1, %eax
je 0x4de06
jmp 0x4dded
movl -0x114(%rbp), %eax
testl %eax, %eax
je 0x4de2a
jmp 0x4ddf9
movl -0x114(%rbp), %eax
subl $0x1, %eax
je 0x4de2c
jmp 0x4de4c
movl -0xc8(%rbp), %ecx
movl -0x54(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x54(%rbp)
movl -0xcc(%rbp), %ecx
movl -0x58(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x58(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x4de7c
jmp 0x4de7c
movl -0xc8(%rbp), %eax
addl -0x54(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0xcc(%rbp), %eax
addl -0x58(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x4de7c
movl -0xc8(%rbp), %eax
movl -0x68(%rbp), %ecx
subl -0x50(%rbp), %ecx
imull %ecx, %eax
addl -0x54(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0xcc(%rbp), %eax
movl -0x68(%rbp), %ecx
subl -0x50(%rbp), %ecx
imull %ecx, %eax
addl -0x58(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x50(%rbp)
movslq -0x68(%rbp), %rcx
leaq 0x403bf9(%rip), %rax    # 0x451a80
movl (%rax,%rcx,4), %eax
addl -0x5c(%rbp), %eax
cltq
leaq 0x16cd7a(%rip), %rcx    # 0x1bac10
addq (%rcx), %rax
movq %rax, -0x90(%rbp)
movzbl 0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4df4c
movzbl 0x18(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4df04
movl -0x54(%rbp), %edi
andl $0xffff, %edi           # imm = 0xFFFF
movl -0x58(%rbp), %esi
andl $0xffff, %esi           # imm = 0xFFFF
movl -0x70(%rbp), %edx
subl -0x68(%rbp), %edx
addl $0x1, %edx
movl -0x54(%rbp), %eax
sarl $0x10, %eax
imull -0xa8(%rbp), %eax
movl -0x58(%rbp), %ecx
sarl $0x10, %ecx
addl %ecx, %eax
movslq %eax, %rcx
addq -0x98(%rbp), %rcx
movq -0x90(%rbp), %r8
callq 0xa7ee0
jmp 0x4df4a
movl -0x54(%rbp), %edi
andl $0xffff, %edi           # imm = 0xFFFF
movl -0x58(%rbp), %esi
andl $0xffff, %esi           # imm = 0xFFFF
movl -0x70(%rbp), %edx
subl -0x68(%rbp), %edx
addl $0x1, %edx
movl -0x54(%rbp), %eax
sarl $0x10, %eax
imull -0xa8(%rbp), %eax
movl -0x58(%rbp), %ecx
sarl $0x10, %ecx
addl %ecx, %eax
movslq %eax, %rcx
addq -0x98(%rbp), %rcx
movq -0x90(%rbp), %r8
callq 0xa7fc0
jmp 0x4df92
movl -0x54(%rbp), %edi
andl $0xffff, %edi           # imm = 0xFFFF
movl -0x58(%rbp), %esi
andl $0xffff, %esi           # imm = 0xFFFF
movl -0x70(%rbp), %edx
subl -0x68(%rbp), %edx
addl $0x1, %edx
movl -0x54(%rbp), %eax
sarl $0x10, %eax
imull -0xa8(%rbp), %eax
movl -0x58(%rbp), %ecx
sarl $0x10, %ecx
addl %ecx, %eax
movslq %eax, %rcx
addq -0x98(%rbp), %rcx
movq -0x90(%rbp), %r8
callq 0xa80b0
callq 0xc220
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x4dd29
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)