// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cmd_line.cc
// Function: main
int main(int argc,char **argv) {
	int i=1,j=-7,custom_output=0,nx,ny,nz,init_mem(8);
	double ls=0;
	blocks_mode bm=none;
	bool gnuplot_output=false,povp_output=false,povv_output=false,polydisperse=false;
	bool xperiodic=false,yperiodic=false,zperiodic=false,ordered=false,verbose=false;
	pre_container *pcon=NULL;pre_container_poly *pconp=NULL;
	wall_list wl;

	// If there's one argument, check to see if it's requesting help.
	// Otherwise, bail out with an error.
	if(argc==2) {
		if(strcmp(argv[1],"-h")==0||strcmp(argv[1],"--help")==0) {
			help_message();return 0;
		} else if(strcmp(argv[1],"-hc")==0) {
			custom_output_message();return 0;
		} else if(strcmp(argv[1],"--version")==0) {
			version_message();return 0;
		} else {
			error_message();
			return VOROPP_CMD_LINE_ERROR;
		}
	}

	// If there aren't enough command-line arguments, then bail out
	// with an error.
	if(argc<7) {
	       error_message();
	       return VOROPP_CMD_LINE_ERROR;
	}

	// We have enough arguments. Now start searching for command-line
	// options.
	while(i<argc-7) {
		if(strcmp(argv[i],"-c")==0) {
			if(i>=argc-8) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			if(custom_output==0) {
				custom_output=++i;
			} else {
				fputs("voro++: multiple custom output strings detected\n",stderr);
				wl.deallocate();
				return VOROPP_CMD_LINE_ERROR;
			}
		} else if(strcmp(argv[i],"-g")==0) {
			gnuplot_output=true;
		} else if(strcmp(argv[i],"-h")==0||strcmp(argv[i],"--help")==0) {
			help_message();wl.deallocate();return 0;
		} else if(strcmp(argv[i],"-hc")==0) {
			custom_output_message();wl.deallocate();return 0;
		} else if(strcmp(argv[i],"-l")==0) {
			if(i>=argc-8) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			if(bm!=none) {
				fputs("voro++: Conflicting options about grid setup (-l/-n)\n",stderr);
				wl.deallocate();
				return VOROPP_CMD_LINE_ERROR;
			}
			bm=length_scale;
			i++;ls=atof(argv[i]);
		} else if(strcmp(argv[i],"-m")==0) {
			i++;init_mem=atoi(argv[i]);
		} else if(strcmp(argv[i],"-n")==0) {
			if(i>=argc-10) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			if(bm!=none) {
				fputs("voro++: Conflicting options about grid setup (-l/-n)\n",stderr);
				wl.deallocate();
				return VOROPP_CMD_LINE_ERROR;
			}
			bm=specified;
			i++;
			nx=atoi(argv[i++]);
			ny=atoi(argv[i++]);
			nz=atoi(argv[i]);
			if(nx<=0||ny<=0||nz<=0) {
				fputs("voro++: Computational grid specified with -n must be greater than one\n"
				      "in each direction\n",stderr);
				wl.deallocate();
				return VOROPP_CMD_LINE_ERROR;
			}
		} else if(strcmp(argv[i],"-o")==0) {
			ordered=true;
		} else if(strcmp(argv[i],"-p")==0) {
			xperiodic=yperiodic=zperiodic=true;
		} else if(strcmp(argv[i],"-px")==0) {
			xperiodic=true;
		} else if(strcmp(argv[i],"-py")==0) {
			yperiodic=true;
		} else if(strcmp(argv[i],"-pz")==0) {
			zperiodic=true;
		} else if(strcmp(argv[i],"-r")==0) {
			polydisperse=true;
		} else if(strcmp(argv[i],"-v")==0) {
			verbose=true;
		} else if(strcmp(argv[i],"--version")==0) {
			version_message();
			wl.deallocate();
			return 0;
		} else if(strcmp(argv[i],"-wb")==0) {
			if(i>=argc-13) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			i++;
			double w0=atof(argv[i++]),w1=atof(argv[i++]);
			double w2=atof(argv[i++]),w3=atof(argv[i++]);
			double w4=atof(argv[i++]),w5=atof(argv[i]);
			wl.add_wall(new wall_plane(-1,0,0,-w0,j));j--;
			wl.add_wall(new wall_plane(1,0,0,w1,j));j--;
			wl.add_wall(new wall_plane(0,-1,0,-w2,j));j--;
			wl.add_wall(new wall_plane(0,1,0,w3,j));j--;
			wl.add_wall(new wall_plane(0,0,-1,-w4,j));j--;
			wl.add_wall(new wall_plane(0,0,1,w5,j));j--;
		} else if(strcmp(argv[i],"-ws")==0) {
			if(i>=argc-11) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			i++;
			double w0=atof(argv[i++]),w1=atof(argv[i++]);
			double w2=atof(argv[i++]),w3=atof(argv[i]);
			wl.add_wall(new wall_sphere(w0,w1,w2,w3,j));
			j--;
		} else if(strcmp(argv[i],"-wp")==0) {
			if(i>=argc-11) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			i++;
			double w0=atof(argv[i++]),w1=atof(argv[i++]);
			double w2=atof(argv[i++]),w3=atof(argv[i]);
			wl.add_wall(new wall_plane(w0,w1,w2,w3,j));
			j--;
		} else if(strcmp(argv[i],"-wc")==0) {
			if(i>=argc-14) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			i++;
			double w0=atof(argv[i++]),w1=atof(argv[i++]);
			double w2=atof(argv[i++]),w3=atof(argv[i++]);
			double w4=atof(argv[i++]),w5=atof(argv[i++]);
			double w6=atof(argv[i]);
			wl.add_wall(new wall_cylinder(w0,w1,w2,w3,w4,w5,w6,j));
			j--;
		} else if(strcmp(argv[i],"-wo")==0) {
			if(i>=argc-14) {error_message();wl.deallocate();return VOROPP_CMD_LINE_ERROR;}
			i++;
			double w0=atof(argv[i++]),w1=atof(argv[i++]);
			double w2=atof(argv[i++]),w3=atof(argv[i++]);
			double w4=atof(argv[i++]),w5=atof(argv[i++]);
			double w6=atof(argv[i]);
			wl.add_wall(new wall_cone(w0,w1,w2,w3,w4,w5,w6,j));
			j--;
		} else if(strcmp(argv[i],"-y")==0) {
			povp_output=povv_output=true;
		} else if(strcmp(argv[i],"-yp")==0) {
			povp_output=true;
		} else if(strcmp(argv[i],"-yv")==0) {
			povv_output=true;
		} else {
			wl.deallocate();
			error_message();
			return VOROPP_CMD_LINE_ERROR;
		}
		i++;
	}

	// Check the memory guess is positive
	if(init_mem<=0) {
		fputs("voro++: The memory allocation must be positive\n",stderr);
		wl.deallocate();
		return VOROPP_CMD_LINE_ERROR;
	}

	// Read in the dimensions of the test box, and estimate the number of
	// boxes to divide the region up into
	double ax=atof(argv[i]),bx=atof(argv[i+1]);
	double ay=atof(argv[i+2]),by=atof(argv[i+3]);
	double az=atof(argv[i+4]),bz=atof(argv[i+5]);

	// Check that for each coordinate, the minimum value is smaller
	// than the maximum value
	if(bx<ax) {
		fputs("voro++: Minimum x coordinate exceeds maximum x coordinate\n",stderr);
		wl.deallocate();
		return VOROPP_CMD_LINE_ERROR;
	}
	if(by<ay) {
		fputs("voro++: Minimum y coordinate exceeds maximum y coordinate\n",stderr);
		wl.deallocate();
		return VOROPP_CMD_LINE_ERROR;
	}
	if(bz<az) {
		fputs("voro++: Minimum z coordinate exceeds maximum z coordinate\n",stderr);
		wl.deallocate();
		return VOROPP_CMD_LINE_ERROR;
	}

	if(bm==none) {
		if(polydisperse) {
			pconp=new pre_container_poly(ax,bx,ay,by,az,bz,xperiodic,yperiodic,zperiodic);
			pconp->import(argv[i+6]);
			pconp->guess_optimal(nx,ny,nz);
		} else {
			pcon=new pre_container(ax,bx,ay,by,az,bz,xperiodic,yperiodic,zperiodic);
			pcon->import(argv[i+6]);
			pcon->guess_optimal(nx,ny,nz);
		}
	} else {
		double nxf,nyf,nzf;
		if(bm==length_scale) {

			// Check that the length scale is positive and
			// reasonably large
			if(ls<tolerance) {
				fputs("voro++: ",stderr);
				if(ls<0) {
					fputs("The length scale must be positive\n",stderr);
				} else {
					fprintf(stderr,"The length scale is smaller than the safe limit of %g. Either\nincrease the particle length scale, or recompile with a different limit.\n",tolerance);
				}
				wl.deallocate();
				return VOROPP_CMD_LINE_ERROR;
			}
			ls=0.6/ls;
			nxf=(bx-ax)*ls+1;
			nyf=(by-ay)*ls+1;
			nzf=(bz-az)*ls+1;

			nx=int(nxf);ny=int(nyf);nz=int(nzf);
		} else {
			nxf=nx;nyf=ny;nzf=nz;
		}

		// Compute the number regions based on the length scale
		// provided. If the total number exceeds a cutoff then bail
		// out, to prevent making a massive memory allocation. Do this
		// test using floating point numbers, since huge integers could
		// potentially wrap around to negative values.
		if(nxf*nyf*nzf>max_regions) {
			fprintf(stderr,"voro++: Number of computational blocks exceeds the maximum allowed of %d.\n"
				       "Either increase the particle length scale, or recompile with an increased\nmaximum.",max_regions);
			wl.deallocate();
			return VOROPP_MEMORY_ERROR;
		}
	}

	// Check that the output filename is a sensible length
	int flen=strlen(argv[i+6]);
	if(flen>4096) {
		fputs("voro++: Filename too long\n",stderr);
		wl.deallocate();
		return VOROPP_CMD_LINE_ERROR;
	}

	// Open files for output
	char *buffer=new char[flen+7];
	sprintf(buffer,"%s.vol",argv[i+6]);
	FILE *outfile=safe_fopen(buffer,"w"),*gnu_file,*povp_file,*povv_file;
	if(gnuplot_output) {
		sprintf(buffer,"%s.gnu",argv[i+6]);
		gnu_file=safe_fopen(buffer,"w");
	} else gnu_file=NULL;
	if(povp_output) {
		sprintf(buffer,"%s_p.pov",argv[i+6]);
		povp_file=safe_fopen(buffer,"w");
	} else povp_file=NULL;
	if(povv_output) {
		sprintf(buffer,"%s_v.pov",argv[i+6]);
		povv_file=safe_fopen(buffer,"w");
	} else povv_file=NULL;
	delete [] buffer;

	const char *c_str=(custom_output==0?(polydisperse?"%i %q %v %r":"%i %q %v"):argv[custom_output]);

	// Now switch depending on whether polydispersity was enabled, and
	// whether output ordering is requested
	double vol=0;int tp=0,vcc=0;
	if(polydisperse) {
		if(ordered) {
			particle_order vo;
			container_poly con(ax,bx,ay,by,az,bz,nx,ny,nz,xperiodic,yperiodic,zperiodic,init_mem);
			con.add_wall(wl);
			if(bm==none) {
				pconp->setup(vo,con);delete pconp;
			} else con.import(vo,argv[i+6]);

			c_loop_order vlo(con,vo);
			cmd_line_output(vlo,con,c_str,outfile,gnu_file,povp_file,povv_file,verbose,vol,vcc,tp);
		} else {
			container_poly con(ax,bx,ay,by,az,bz,nx,ny,nz,xperiodic,yperiodic,zperiodic,init_mem);
			con.add_wall(wl);

			if(bm==none) {
				pconp->setup(con);delete pconp;
			} else con.import(argv[i+6]);

			c_loop_all vla(con);
			cmd_line_output(vla,con,c_str,outfile,gnu_file,povp_file,povv_file,verbose,vol,vcc,tp);
		}
	} else {
		if(ordered) {
			particle_order vo;
			container con(ax,bx,ay,by,az,bz,nx,ny,nz,xperiodic,yperiodic,zperiodic,init_mem);
			con.add_wall(wl);
			if(bm==none) {
				pcon->setup(vo,con);delete pcon;
			} else con.import(vo,argv[i+6]);

			c_loop_order vlo(con,vo);
			cmd_line_output(vlo,con,c_str,outfile,gnu_file,povp_file,povv_file,verbose,vol,vcc,tp);
		} else {
			container con(ax,bx,ay,by,az,bz,nx,ny,nz,xperiodic,yperiodic,zperiodic,init_mem);
			con.add_wall(wl);
			if(bm==none) {
				pcon->setup(con);delete pcon;
			} else con.import(argv[i+6]);
			c_loop_all vla(con);
			cmd_line_output(vla,con,c_str,outfile,gnu_file,povp_file,povv_file,verbose,vol,vcc,tp);
		}
	}

	// Print information if verbose output requested
	if(verbose) {
		printf("Container geometry        : [%g:%g] [%g:%g] [%g:%g]\n"
		       "Computational grid size   : %d by %d by %d (%s)\n"
		       "Filename                  : %s\n"
		       "Output string             : %s%s\n",ax,bx,ay,by,az,bz,nx,ny,nz,
		       bm==none?"estimated from file":(bm==length_scale?
		       "estimated using length scale":"directly specified"),
		       argv[i+6],c_str,custom_output==0?" (default)":"");
		printf("Total imported particles  : %d (%.2g per grid block)\n"
		       "Total V. cells computed   : %d\n"
		       "Total container volume    : %g\n"
		       "Total V. cell volume      : %g\n",tp,((double) tp)/(nx*ny*nz),
		       vcc,(bx-ax)*(by-ay)*(bz-az),vol);
	}

	// Close output files
	fclose(outfile);
	if(gnu_file!=NULL) fclose(gnu_file);
	if(povp_file!=NULL) fclose(povp_file);
	if(povv_file!=NULL) fclose(povv_file);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x378, %rsp            # imm = 0x378
movq %rsi, %rbx
movl %edi, %r15d
leaq 0xc0(%rsp), %rdi
callq 0x104c8
cmpl $0x2, %r15d
jne 0x2420
movq 0x8(%rbx), %rbx
cmpb $0x2d, (%rbx)
jne 0x23d9
cmpb $0x68, 0x1(%rbx)
jne 0x23d9
cmpb $0x0, 0x2(%rbx)
je 0x2e9d
leaq 0x2dc86(%rip), %rsi     # 0x30066
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x2e9d
leaq 0x2dc76(%rip), %rsi     # 0x3006d
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x2ea7
leaq 0x2dc63(%rip), %rsi     # 0x30071
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x3006
jmp 0x2426
cmpl $0x7, %r15d
jge 0x2433
callq 0x2380
pushq $0x4
popq %rbx
jmp 0x38d2
leal -0x7(%r15), %eax
movl %eax, 0x48(%rsp)
leal -0xe(%r15), %eax
movl %eax, 0xe4(%rsp)
leal -0xb(%r15), %eax
movl %eax, 0x18(%rsp)
leal -0xd(%r15), %eax
movl %eax, 0x30(%rsp)
leal -0xa(%r15), %eax
movl %eax, 0x38(%rsp)
addl $-0x8, %r15d
pushq $0x1
popq %r13
pushq $-0x7
popq %rax
movq %rax, (%rsp)
pushq $0x8
popq %rax
movq %rax, 0xa8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0xa0(%rsp)
leaq 0x3c82d(%rip), %rax     # 0x3ecc0
addq $0x10, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movhps 0x2cb82(%rip), %xmm0    # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, 0x140(%rsp)
xorps %xmm0, %xmm0
movhps 0x2cb60(%rip), %xmm0    # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, 0x120(%rsp)
leaq 0x3c7a9(%rip), %rax     # 0x3ec70
addq $0x10, %rax
movq %rax, 0x90(%rsp)
leaq 0x3c836(%rip), %rax     # 0x3ed10
addq $0x10, %rax
movq %rax, 0x168(%rsp)
movl $0x0, 0xa4(%rsp)
movl $0x0, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movl $0x0, 0x80(%rsp)
movl $0x0, 0x8c(%rsp)
movl $0x0, 0x9c(%rsp)
movl $0x0, 0x98(%rsp)
movl $0x0, 0x68(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x64(%rsp)
movslq %r13d, %r12
cmpl 0x48(%rsp), %r13d
jge 0x2eb1
movq (%rbx,%r12,8), %r14
movb (%r14), %bpl
cmpb $0x2d, %bpl
jne 0x2596
cmpb $0x63, 0x1(%r14)
jne 0x2572
cmpb $0x0, 0x2(%r14)
je 0x277c
cmpb $0x67, 0x1(%r14)
jne 0x2584
cmpb $0x0, 0x2(%r14)
je 0x27a8
cmpb $0x68, 0x1(%r14)
jne 0x2596
cmpb $0x0, 0x2(%r14)
je 0x2fff
movq %r14, %rdi
leaq 0x2dac6(%rip), %rsi     # 0x30066
callq 0x2190
testl %eax, %eax
je 0x2fff
movq %r14, %rdi
leaq 0x2dab6(%rip), %rsi     # 0x3006d
callq 0x2190
testl %eax, %eax
je 0x3010
cmpb $0x2d, %bpl
jne 0x2624
cmpb $0x6c, 0x1(%r14)
jne 0x25dc
cmpb $0x0, 0x2(%r14)
je 0x27b3
cmpb $0x6d, 0x1(%r14)
jne 0x25ee
cmpb $0x0, 0x2(%r14)
je 0x27de
cmpb $0x6e, 0x1(%r14)
jne 0x2600
cmpb $0x0, 0x2(%r14)
je 0x27f8
cmpb $0x6f, 0x1(%r14)
jne 0x2612
cmpb $0x0, 0x2(%r14)
je 0x2866
cmpb $0x70, 0x1(%r14)
jne 0x2624
cmpb $0x0, 0x2(%r14)
je 0x2aa3
movq %r14, %rdi
leaq 0x2db0d(%rip), %rsi     # 0x3013b
callq 0x2190
testl %eax, %eax
je 0x2aaf
movq %r14, %rdi
leaq 0x2dafa(%rip), %rsi     # 0x3013f
callq 0x2190
testl %eax, %eax
je 0x2771
movq %r14, %rdi
leaq 0x2dae7(%rip), %rsi     # 0x30143
callq 0x2190
testl %eax, %eax
je 0x279d
cmpb $0x2d, %bpl
jne 0x2693
cmpb $0x72, 0x1(%r14)
jne 0x2681
cmpb $0x0, 0x2(%r14)
je 0x2c2e
cmpb $0x76, 0x1(%r14)
jne 0x2693
cmpb $0x0, 0x2(%r14)
je 0x2c39
movq %r14, %rdi
leaq 0x2d9d4(%rip), %rsi     # 0x30071
callq 0x2190
testl %eax, %eax
je 0x35f4
movq %r14, %rdi
leaq 0x2da93(%rip), %rsi     # 0x30147
callq 0x2190
testl %eax, %eax
je 0x2874
movq %r14, %rdi
leaq 0x2da80(%rip), %rsi     # 0x3014b
callq 0x2190
testl %eax, %eax
je 0x2abd
movq %r14, %rdi
leaq 0x2da6d(%rip), %rsi     # 0x3014f
callq 0x2190
testl %eax, %eax
je 0x2b70
movq %r14, %rdi
leaq 0x2da5a(%rip), %rsi     # 0x30153
callq 0x2190
testl %eax, %eax
je 0x2c44
movq %r14, %rdi
leaq 0x2da47(%rip), %rsi     # 0x30157
callq 0x2190
testl %eax, %eax
je 0x2d86
cmpb $0x2d, %bpl
jne 0x2735
cmpb $0x79, 0x1(%r14)
jne 0x2735
cmpb $0x0, 0x2(%r14)
je 0x2e86
movq %r14, %rdi
leaq 0x2da1c(%rip), %rsi     # 0x3015b
callq 0x2190
testl %eax, %eax
je 0x2e8f
movq %r14, %rdi
leaq 0x2da09(%rip), %rsi     # 0x3015f
callq 0x2190
movb $0x1, %cl
movl %ecx, 0x9c(%rsp)
testl %eax, %eax
je 0x2c26
jmp 0x3bf9
movb $0x1, %al
movl %eax, 0x58(%rsp)
jmp 0x2c26
cmpl %r15d, %r13d
jge 0x35fe
cmpl $0x0, 0x64(%rsp)
jne 0x3be3
incl %r13d
movl %r13d, 0x64(%rsp)
jmp 0x2c26
movb $0x1, %al
movl %eax, 0x50(%rsp)
jmp 0x2c26
movb $0x1, %al
movl %eax, 0x68(%rsp)
jmp 0x2c26
cmpl %r15d, %r13d
jge 0x3603
cmpl $0x0, 0x8(%rsp)
jne 0x3b4d
incl %r13d
movq 0x8(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x40(%rsp)
pushq $0x1
jmp 0x285c
incl %r13d
movq 0x8(%rbx,%r12,8), %rdi
callq 0x21d0
movq %rax, 0xa8(%rsp)
jmp 0x2c26
cmpl 0x38(%rsp), %r13d
jge 0x3ae3
cmpl $0x0, 0x8(%rsp)
jne 0x3b4d
movq 0x8(%rbx,%r12,8), %rdi
callq 0x21d0
movl %eax, %ebp
movl %eax, 0x14(%rsp)
movq 0x10(%rbx,%r12,8), %rdi
callq 0x21d0
movl %eax, %r14d
movl %eax, 0x10(%rsp)
movq 0x18(%rbx,%r12,8), %rdi
callq 0x21d0
movl %eax, 0xc(%rsp)
testl %ebp, %ebp
jle 0x3c0b
testl %r14d, %r14d
jle 0x3c0b
testl %eax, %eax
jle 0x3c0b
addl $0x3, %r13d
pushq $0x2
popq %rax
movl %eax, 0x8(%rsp)
jmp 0x2c26
movb $0x1, %al
movl %eax, 0xa4(%rsp)
jmp 0x2c26
cmpl 0x30(%rsp), %r13d
jge 0x3b10
movq 0x8(%rbx,%r12,8), %rdi
callq 0x2160
movaps %xmm0, 0x110(%rsp)
movq 0x10(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x78(%rsp)
movq 0x18(%rbx,%r12,8), %rdi
callq 0x2160
movaps %xmm0, 0x100(%rsp)
movq 0x20(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x70(%rsp)
movq 0x28(%rbx,%r12,8), %rdi
callq 0x2160
movaps %xmm0, 0x150(%rsp)
movq 0x30(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0xb8(%rsp)
pushq $0x30
popq %rdi
callq 0x2110
movq (%rsp), %r14
movq 0x20(%rsp), %r12
movapd 0x110(%rsp), %xmm1
xorpd 0x2c736(%rip), %xmm1    # 0x2f040
movq %r12, (%rax)
movl %r14d, 0x8(%rax)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movlpd %xmm1, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
pushq $0x30
popq %rdi
callq 0x2110
leal -0x1(%r14), %ecx
movq %r12, (%rax)
movl %ecx, 0x8(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
pushq $0x30
popq %rdi
callq 0x2110
leal -0x2(%r14), %ecx
movapd 0x100(%rsp), %xmm1
xorpd 0x2c6a6(%rip), %xmm1    # 0x2f040
movq %r12, (%rax)
movl %ecx, 0x8(%rax)
movaps 0x140(%rsp), %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movlpd %xmm1, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
pushq $0x30
popq %rdi
callq 0x2110
leal -0x3(%r14), %ecx
movq %r12, (%rax)
movl %ecx, 0x8(%rax)
movaps 0x120(%rsp), %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
pushq $0x30
popq %rdi
callq 0x2110
leal -0x4(%r14), %ecx
movapd 0x150(%rsp), %xmm1
xorpd 0x2c61f(%rip), %xmm1    # 0x2f040
movq %r12, (%rax)
movl %ecx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x20(%rax)
movlpd %xmm1, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
pushq $0x30
popq %rdi
callq 0x2110
leal -0x5(%r14), %ecx
movq %r12, (%rax)
movl %ecx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x20(%rax)
movsd 0xb8(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
addl $0x6, %r13d
addl $-0x6, %r14d
jmp 0x2c22
movb $0x1, %al
movl %eax, 0x50(%rsp)
movb $0x1, %al
movl %eax, 0x58(%rsp)
movb $0x1, %al
movl %eax, 0x80(%rsp)
jmp 0x2c26
cmpl 0x18(%rsp), %r13d
jge 0x3b46
movq 0x8(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x110(%rsp)
movq 0x10(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x78(%rsp)
movq 0x18(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x100(%rsp)
movq 0x20(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x70(%rsp)
pushq $0x30
popq %rdi
callq 0x2110
movq (%rsp), %r14
movq 0x90(%rsp), %rcx
movq %rcx, (%rax)
movl %r14d, 0x8(%rax)
movsd 0x110(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
jmp 0x2c1b
cmpl 0x18(%rsp), %r13d
jge 0x3b4b
movq 0x8(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x110(%rsp)
movq 0x10(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x78(%rsp)
movq 0x18(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x100(%rsp)
movq 0x20(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x70(%rsp)
pushq $0x30
popq %rdi
callq 0x2110
movq (%rsp), %r14
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movl %r14d, 0x8(%rax)
movsd 0x110(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
addl $0x4, %r13d
decl %r14d
movq %r14, (%rsp)
incl %r13d
jmp 0x2545
movb $0x1, %al
movl %eax, 0x8c(%rsp)
jmp 0x2c26
movb $0x1, %al
movl %eax, 0xa0(%rsp)
jmp 0x2c26
cmpl 0xe4(%rsp), %r13d
jge 0x3b9f
movq 0x8(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x110(%rsp)
movq 0x10(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x100(%rsp)
movq 0x18(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x70(%rsp)
movq 0x20(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x78(%rsp)
movq 0x28(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x150(%rsp)
movq 0x30(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0xb8(%rsp)
movq 0x38(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x138(%rsp)
pushq $0x50
popq %rdi
callq 0x2110
movq (%rsp), %r14
movq 0x168(%rsp), %rcx
movq %rcx, (%rax)
movl %r14d, 0x8(%rax)
movsd 0x110(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x150(%rsp), %xmm1
movsd %xmm1, 0x30(%rax)
movsd 0xb8(%rsp), %xmm2
movsd %xmm2, 0x38(%rax)
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
movsd 0x2c2c2(%rip), %xmm0    # 0x2f018
divsd %xmm2, %xmm0
movsd %xmm0, 0x40(%rax)
movsd 0x138(%rsp), %xmm0
movsd %xmm0, 0x48(%rax)
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0x3cdc
addl $0x7, %r13d
jmp 0x2c1f
cmpl 0xe4(%rsp), %r13d
jge 0x3bcc
movq 0x8(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x110(%rsp)
movq 0x10(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x78(%rsp)
movq 0x18(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x100(%rsp)
movq 0x20(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x70(%rsp)
movq 0x28(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x150(%rsp)
movq 0x30(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0xb8(%rsp)
movq 0x38(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x138(%rsp)
pushq $0x60
popq %rdi
callq 0x2110
movq (%rsp), %r12
movq %rax, %r14
movq %rax, %rdi
movsd 0x110(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
movsd 0x100(%rsp), %xmm2
movsd 0x70(%rsp), %xmm3
movsd 0x150(%rsp), %xmm4
movsd 0xb8(%rsp), %xmm5
movsd 0x138(%rsp), %xmm6
movl %r12d, %esi
callq 0x3d10
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x3cdc
addl $0x7, %r13d
decl %r12d
movq %r12, (%rsp)
jmp 0x2c26
movb $0x1, %al
movl %eax, 0x9c(%rsp)
movb $0x1, %al
movl %eax, 0x98(%rsp)
jmp 0x2c26
callq 0x235c
jmp 0x38d0
callq 0x2368
jmp 0x38d0
cmpl $0x0, 0xa8(%rsp)
jle 0x3a8e
movq (%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x48(%rsp)
movq 0x8(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, (%rsp)
movq 0x10(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x38(%rsp)
movq 0x20(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x30(%rsp)
movq 0x28(%rbx,%r12,8), %rdi
callq 0x2160
movsd %xmm0, 0x18(%rsp)
movsd 0x48(%rsp), %xmm0
ucomisd (%rsp), %xmm0
ja 0x3aa9
movsd 0x20(%rsp), %xmm0
ucomisd 0x38(%rsp), %xmm0
ja 0x3ab2
movsd 0x30(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
ja 0x3abb
movzbl 0x80(%rsp), %ebp
movzbl 0x58(%rsp), %r14d
movzbl 0x50(%rsp), %r13d
movl 0x8(%rsp), %eax
testl %eax, %eax
je 0x3029
cmpl $0x1, %eax
jne 0x30ae
movsd 0x2c085(%rip), %xmm0    # 0x2f008
movsd 0x40(%rsp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3b63
movsd 0x2c075(%rip), %xmm3    # 0x2f010
divsd %xmm1, %xmm3
movsd (%rsp), %xmm0
subsd 0x48(%rsp), %xmm0
mulsd %xmm3, %xmm0
movsd 0x2c062(%rip), %xmm4    # 0x2f018
addsd %xmm4, %xmm0
movsd 0x38(%rsp), %xmm1
subsd 0x20(%rsp), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm4, %xmm1
movsd 0x18(%rsp), %xmm2
subsd 0x30(%rsp), %xmm2
mulsd %xmm3, %xmm2
cvttsd2si %xmm0, %eax
addsd %xmm4, %xmm2
movl %eax, 0x14(%rsp)
cvttsd2si %xmm1, %eax
movl %eax, 0x10(%rsp)
cvttsd2si %xmm2, %eax
movl %eax, 0xc(%rsp)
jmp 0x30c0
callq 0x235c
jmp 0x3015
callq 0x2374
jmp 0x38d0
callq 0x2368
xorl %ebx, %ebx
leaq 0xc0(%rsp), %rdi
callq 0x11b0a
jmp 0x38d2
testb $0x1, 0x8c(%rsp)
je 0x33f0
movl $0x80, %edi
callq 0x2110
movq %rax, %r15
movl %ebp, %esi
andl $0x1, %esi
movl %r14d, %edx
andl $0x1, %edx
movl %r13d, %ecx
andl $0x1, %ecx
movq %rax, %rdi
movsd 0x48(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x18(%rsp), %xmm5
callq 0x3da6
movq 0x30(%rbx,%r12,8), %rsi
movq %r15, %rdi
callq 0x3db0
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
callq 0x29118
movq %r15, 0x120(%rsp)
jmp 0x30e2
cvtsi2sdl 0x14(%rsp), %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
cvtsi2sdl 0xc(%rsp), %xmm2
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
ucomisd 0x2bf50(%rip), %xmm0    # 0x2f020
ja 0x3b15
movq $0x0, 0x120(%rsp)
movq $0x0, 0x90(%rsp)
movq 0x30(%rbx,%r12,8), %r15
movq %r15, %rdi
callq 0x20a0
cmpl $0x1001, %eax           # imm = 0x1001
jge 0x3ae8
movq %r13, 0x140(%rsp)
addl $0x7, %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r13
leaq 0x2d28d(%rip), %rsi     # 0x303b0
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x2d280(%rip), %rsi     # 0x303b7
movq %r13, %rdi
callq 0xfe5b
movq %rax, 0x80(%rsp)
testb $0x1, 0x68(%rsp)
movl 0x64(%rsp), %r15d
je 0x317f
movq 0x30(%rbx,%r12,8), %rdx
leaq 0x2d25a(%rip), %rsi     # 0x303b9
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x2d247(%rip), %rsi     # 0x303b7
movq %r13, %rdi
callq 0xfe5b
movq %rax, 0x58(%rsp)
jmp 0x3188
movq $0x0, 0x58(%rsp)
testb $0x1, 0x98(%rsp)
je 0x31be
movq 0x30(%rbx,%r12,8), %rdx
leaq 0x2d222(%rip), %rsi     # 0x303c0
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x2d208(%rip), %rsi     # 0x303b7
movq %r13, %rdi
callq 0xfe5b
movq %rax, 0x50(%rsp)
jmp 0x31c7
movq $0x0, 0x50(%rsp)
testb $0x1, 0x9c(%rsp)
je 0x31fd
movq 0x30(%rbx,%r12,8), %rdx
leaq 0x2d1ec(%rip), %rsi     # 0x303c9
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x2d1c9(%rip), %rsi     # 0x303b7
movq %r13, %rdi
callq 0xfe5b
movq %rax, 0x68(%rsp)
jmp 0x3206
movq $0x0, 0x68(%rsp)
movq %r13, %rdi
callq 0x2170
testl %r15d, %r15d
je 0x3249
movslq %r15d, %rax
movq (%rbx,%rax,8), %rax
movq %rax, 0x40(%rsp)
andq $0x0, 0xb0(%rsp)
andl $0x0, 0x2c(%rsp)
andl $0x0, 0x28(%rsp)
testb $0x1, 0x8c(%rsp)
movl 0xa0(%rsp), %r13d
jne 0x327e
jmp 0x3482
andq $0x0, 0xb0(%rsp)
andl $0x0, 0x2c(%rsp)
andl $0x0, 0x28(%rsp)
testb $0x1, 0x8c(%rsp)
movl 0xa0(%rsp), %r13d
je 0x3476
leaq 0x2d159(%rip), %rax     # 0x303d2
movq %rax, 0x40(%rsp)
testb $0x1, 0xa4(%rsp)
je 0x3356
movl $0x8000, %edi           # imm = 0x8000
callq 0x2030
movq %rax, 0xe8(%rsp)
movq %rax, 0xf0(%rsp)
movl $0x1000, 0xf8(%rsp) # imm = 0x1000
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq 0x140(%rsp), %rax
andl $0x1, %eax
andl $0x1, %ebp
andl $0x1, %r14d
leaq 0x170(%rsp), %rdi
movq 0x48(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x18(%rsp), %xmm5
movl %ebp, %r8d
movl %r14d, %r9d
pushq 0xa8(%rsp)
pushq %rax
callq 0x10646
popq %rax
popq %rcx
movq 0x120(%rsp), %r14
leaq 0x1c0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x11ade
cmpl $0x0, 0x8(%rsp)
je 0x38f3
movq 0x30(%rbx,%r12,8), %rdx
leaq 0x170(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x3e26
jmp 0x3920
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq 0x140(%rsp), %rax
andl $0x1, %eax
andl $0x1, %ebp
andl $0x1, %r14d
leaq 0x170(%rsp), %rdi
movq 0x48(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x18(%rsp), %xmm5
movl %ebp, %r8d
movl %r14d, %r9d
pushq 0xa8(%rsp)
pushq %rax
callq 0x10646
popq %rax
popq %rcx
leaq 0x1c0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x11ade
movq 0x50(%rsp), %rbp
cmpl $0x0, 0x8(%rsp)
je 0x3608
movq 0x30(%rbx,%r12,8), %rsi
leaq 0x170(%rsp), %rdi
callq 0x4280
jmp 0x363a
movl $0x80, %edi
callq 0x2110
movq %rax, %r15
movl %ebp, %esi
andl $0x1, %esi
movl %r14d, %edx
andl $0x1, %edx
movl %r13d, %ecx
andl $0x1, %ecx
movq %rax, %rdi
movsd 0x48(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x18(%rsp), %xmm5
callq 0x3de6
movq 0x30(%rbx,%r12,8), %rsi
movq %r15, %rdi
callq 0x3df0
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
callq 0x29118
movq %r15, 0x90(%rsp)
movq $0x0, 0x120(%rsp)
jmp 0x30ee
leaq 0x2cf61(%rip), %rax     # 0x303de
movq %rax, 0x40(%rsp)
testb $0x1, 0xa4(%rsp)
je 0x355a
movl $0x8000, %edi           # imm = 0x8000
callq 0x2030
movq %rax, 0xe8(%rsp)
movq %rax, 0xf0(%rsp)
movl $0x1000, 0xf8(%rsp) # imm = 0x1000
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq 0x140(%rsp), %rax
andl $0x1, %eax
andl $0x1, %ebp
andl $0x1, %r14d
leaq 0x170(%rsp), %rdi
movq 0x48(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x18(%rsp), %xmm5
movl %ebp, %r8d
movl %r14d, %r9d
pushq 0xa8(%rsp)
pushq %rax
callq 0x105a8
popq %rax
popq %rcx
movq 0x90(%rsp), %r14
leaq 0x1c0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x11ade
cmpl $0x0, 0x8(%rsp)
je 0x39b0
movq 0x30(%rbx,%r12,8), %rdx
leaq 0x170(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x4684
jmp 0x39dd
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq 0x140(%rsp), %rax
andl $0x1, %eax
andl $0x1, %ebp
andl $0x1, %r14d
leaq 0x170(%rsp), %rdi
movq 0x48(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x18(%rsp), %xmm5
movl %ebp, %r8d
movl %r14d, %r9d
pushq 0xa8(%rsp)
pushq %rax
callq 0x105a8
popq %rax
popq %rcx
leaq 0x1c0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x11ade
movq 0x50(%rsp), %rbp
cmpl $0x0, 0x8(%rsp)
je 0x36d4
movq 0x30(%rbx,%r12,8), %rsi
leaq 0x170(%rsp), %rdi
callq 0x4ad0
jmp 0x3706
callq 0x2374
jmp 0x3015
jmp 0x3bcc
jmp 0x3bcc
leaq 0x170(%rsp), %rsi
movq 0x120(%rsp), %rdi
callq 0x29492
movq 0x120(%rsp), %r14
movq %r14, %rdi
callq 0x29096
movl $0x80, %esi
movq %r14, %rdi
callq 0x2120
leaq 0x170(%rsp), %rsi
movaps (%rsi), %xmm0
leaq 0x310(%rsp), %rdi
movaps %xmm0, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0xd0(%rsi), %eax
pshufd $0x4e, 0xb0(%rsi), %xmm0 # xmm0 = mem[2,3,0,1]
movl %eax, 0x14(%rdi)
movdqu %xmm0, 0x18(%rdi)
movq 0xc0(%rsi), %rax
movq %rax, 0x28(%rdi)
subq $0x8, %rsp
leaq 0x34(%rsp), %rax
leaq 0x30(%rsp), %r10
leaq 0xb8(%rsp), %r11
movzbl %r13b, %r14d
andl $0x1, %r14d
movq 0x48(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x60(%rsp), %r8
movq %rbp, %r9
pushq %rax
pushq %r10
pushq %r11
pushq %r14
pushq 0x90(%rsp)
callq 0x42b6
addq $0x30, %rsp
leaq 0x170(%rsp), %rdi
callq 0x4258
jmp 0x379b
leaq 0x170(%rsp), %rsi
movq 0x90(%rsp), %rdi
callq 0x293e6
movq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0x29096
movl $0x80, %esi
movq %r14, %rdi
callq 0x2120
leaq 0x170(%rsp), %rsi
movaps (%rsi), %xmm0
leaq 0x310(%rsp), %rdi
movaps %xmm0, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0xd0(%rsi), %eax
pshufd $0x4e, 0xb0(%rsi), %xmm0 # xmm0 = mem[2,3,0,1]
movl %eax, 0x14(%rdi)
movdqu %xmm0, 0x18(%rdi)
movq 0xc0(%rsi), %rax
movq %rax, 0x28(%rdi)
subq $0x8, %rsp
leaq 0x34(%rsp), %rax
leaq 0x30(%rsp), %r10
leaq 0xb8(%rsp), %r11
movzbl %r13b, %r14d
andl $0x1, %r14d
movq 0x48(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x60(%rsp), %r8
movq %rbp, %r9
pushq %rax
pushq %r10
pushq %r11
pushq %r14
pushq 0x90(%rsp)
callq 0x4b06
addq $0x30, %rsp
leaq 0x170(%rsp), %rdi
callq 0x4ab6
testb $0x1, %r13b
movq 0x58(%rsp), %r14
movq 0x68(%rsp), %r13
je 0x389c
movl 0x8(%rsp), %edx
cmpl $0x1, %edx
leaq 0x2cce3(%rip), %rax     # 0x304a0
leaq 0x2ccf9(%rip), %rcx     # 0x304bd
cmoveq %rax, %rcx
testl %edx, %edx
leaq 0x2ccbb(%rip), %r8      # 0x3048c
cmovneq %rcx, %r8
testl %r15d, %r15d
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq 0x30(%rbx,%r12,8), %r9
leaq 0x2cce0(%rip), %rax     # 0x304d0
leaq 0x31e96(%rip), %r10     # 0x3568d
cmoveq %rax, %r10
leaq 0x2cbe5(%rip), %rdi     # 0x303e7
movsd 0x48(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x18(%rsp), %xmm5
movb $0x6, %al
pushq %r10
pushq 0x48(%rsp)
callq 0x2040
popq %rcx
popq %rdx
movl 0x2c(%rsp), %esi
cvtsi2sd %esi, %xmm0
movl 0x10(%rsp), %eax
imull 0x14(%rsp), %eax
imull 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movl 0x28(%rsp), %edx
movsd (%rsp), %xmm2
subsd 0x48(%rsp), %xmm2
movsd 0x38(%rsp), %xmm1
subsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm1
movapd %xmm1, %xmm2
movsd 0x18(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm1
movsd 0xb0(%rsp), %xmm2
leaq 0x2cc46(%rip), %rdi     # 0x304db
movb $0x3, %al
callq 0x2040
movq 0x80(%rsp), %rdi
callq 0x2100
testq %r14, %r14
je 0x38b6
movq %r14, %rdi
callq 0x2100
testq %rbp, %rbp
je 0x38c3
movq %rbp, %rdi
callq 0x2100
testq %r13, %r13
je 0x38d0
movq %r13, %rdi
callq 0x2100
xorl %ebx, %ebx
leaq 0xc0(%rsp), %rdi
callq 0x104f0
movl %ebx, %eax
addq $0x378, %rsp            # imm = 0x378
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe8(%rsp), %rsi
leaq 0x170(%rsp), %rdx
movq %r14, %rdi
callq 0x2960a
movq %r14, %rdi
callq 0x29096
movl $0x80, %esi
movq %r14, %rdi
callq 0x2120
leaq 0x310(%rsp), %r14
leaq 0x170(%rsp), %r15
leaq 0xe8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e5e
subq $0x8, %rsp
leaq 0x34(%rsp), %rax
leaq 0x30(%rsp), %r10
leaq 0xb8(%rsp), %r11
movl %r13d, %ebp
movzbl %bpl, %r13d
andl $0x1, %r13d
movq %r14, %rdi
movq %r15, %rsi
movq 0x48(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x60(%rsp), %r14
movq %r14, %r8
movq 0x58(%rsp), %r9
pushq %rax
pushq %r10
pushq %r11
pushq %r13
movq 0x90(%rsp), %r13
pushq %r13
callq 0x3e8a
addq $0x30, %rsp
leaq 0x170(%rsp), %rdi
callq 0x4258
jmp 0x3a68
leaq 0xe8(%rsp), %rsi
leaq 0x170(%rsp), %rdx
movq %r14, %rdi
callq 0x2954a
movq %r14, %rdi
callq 0x29096
movl $0x80, %esi
movq %r14, %rdi
callq 0x2120
leaq 0x310(%rsp), %r14
leaq 0x170(%rsp), %r15
leaq 0xe8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x46bc
subq $0x8, %rsp
leaq 0x34(%rsp), %rax
leaq 0x30(%rsp), %r10
leaq 0xb8(%rsp), %r11
movl %r13d, %ebp
movzbl %bpl, %r13d
andl $0x1, %r13d
movq %r14, %rdi
movq %r15, %rsi
movq 0x48(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x60(%rsp), %r14
movq %r14, %r8
movq 0x58(%rsp), %r9
pushq %rax
pushq %r10
pushq %r11
pushq %r13
movq 0x90(%rsp), %r13
pushq %r13
callq 0x46e8
addq $0x30, %rsp
leaq 0x170(%rsp), %rdi
callq 0x4ab6
leaq 0xe8(%rsp), %rdi
callq 0x4272
testb $0x1, %bpl
movl 0x64(%rsp), %r15d
movq 0x50(%rsp), %rbp
jne 0x37af
jmp 0x389c
movq 0x3b54b(%rip), %rax     # 0x3efe0
movq (%rax), %rsi
leaq 0x2c6c4(%rip), %rdi     # 0x30163
callq 0x2130
jmp 0x3bd1
leaq 0x2c6e3(%rip), %rdi     # 0x30193
jmp 0x3ac2
leaq 0x2c715(%rip), %rdi     # 0x301ce
jmp 0x3ac2
leaq 0x2c747(%rip), %rdi     # 0x30209
movq 0x3b517(%rip), %rax     # 0x3efe0
movq (%rax), %rsi
callq 0x2130
leaq 0xc0(%rsp), %rdi
callq 0x11b0a
jmp 0x242b
jmp 0x3bcc
movq 0x3b4f1(%rip), %rax     # 0x3efe0
movq (%rax), %rsi
leaq 0x2c89c(%rip), %rdi     # 0x30395
callq 0x2130
leaq 0xc0(%rsp), %rdi
callq 0x11b0a
jmp 0x242b
jmp 0x3bcc
movq 0x3b4c4(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0x2c7d2(%rip), %rsi     # 0x302f8
movl $0x1000000, %edx        # imm = 0x1000000
xorl %eax, %eax
callq 0x21a0
leaq 0xc0(%rsp), %rdi
callq 0x11b0a
pushq $0x2
jmp 0x242d
jmp 0x3bcc
jmp 0x3bcc
movq 0x3b48c(%rip), %rax     # 0x3efe0
movq (%rax), %rsi
leaq 0x2c54e(%rip), %rdi     # 0x300ac
jmp 0x3a9f
movq 0x3b476(%rip), %rbx     # 0x3efe0
movq (%rbx), %rsi
leaq 0x2c6d0(%rip), %rdi     # 0x30244
movsd %xmm1, 0x40(%rsp)
callq 0x2130
xorpd %xmm0, %xmm0
ucomisd 0x40(%rsp), %xmm0
movq (%rbx), %rax
jbe 0x3ba1
leaq 0x2c6b8(%rip), %rdi     # 0x3024d
movq %rax, %rsi
callq 0x2130
jmp 0x3bba
jmp 0x3bcc
leaq 0x2c6c8(%rip), %rsi     # 0x30270
movsd 0x2b458(%rip), %xmm0    # 0x2f008
movq %rax, %rdi
movb $0x1, %al
callq 0x21a0
leaq 0xc0(%rsp), %rdi
callq 0x11b0a
jmp 0x242b
callq 0x2380
leaq 0xc0(%rsp), %rdi
callq 0x11b0a
jmp 0x242b
movq 0x3b3f6(%rip), %rax     # 0x3efe0
movq (%rax), %rsi
leaq 0x2c487(%rip), %rdi     # 0x3007b
jmp 0x3a9f
leaq 0xc0(%rsp), %rdi
callq 0x11b0a
jmp 0x2426
movq 0x3b3ce(%rip), %rax     # 0x3efe0
movq (%rax), %rsi
leaq 0x2c4c6(%rip), %rdi     # 0x300e2
jmp 0x3a9f
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3c2d
movq %rax, %rbx
movl $0x80, %esi
movq %r15, %rdi
callq 0x2120
jmp 0x3cc6
jmp 0x3c5c
jmp 0x3c6e
jmp 0x3c8d
jmp 0x3c9f
movq %rax, %rbx
jmp 0x3c7e
movq %rax, %rbx
jmp 0x3c7e
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x4ab6
jmp 0x3c7e
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x4258
leaq 0xe8(%rsp), %rdi
callq 0x4272
jmp 0x3cc6
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x4ab6
jmp 0x3cc6
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x4258
jmp 0x3cc6
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
jmp 0x3cc3
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x104f0
movq %rbx, %rdi
callq 0x2220
nop