// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: main
int main(argc,argv)

int argc; char *argv[];

{ int sechsecke, i, puffer, do_case;
  char strpuf[filenamenlaenge], strpuf2[filenamenlaenge], strdummy[filenamenlaenge];
  struct stat buf;
  char name[4];     /* TH - fuer die Option "symm" */

#ifndef NOTIMES
  clock_t savetime=0, buffertime;
  struct tms TMS;
#endif //NOTIMES

  int separate_logfile = 1;

#ifdef __GNUC__
#ifdef __alpha__
fprintf(stderr,"With gcc on alphas some errors might occur if you use -O3 or more.\n");
fprintf(stderr,"This is a bug of the compiler.\n");
fprintf(stderr,"Please use cc on alphas -- the result will be a faster program anyway.\n");
exit(0);
#endif
#endif


for (i=1;i<=N;i++) graphenzahl[i]=non_iso_graphenzahl[i]=0;

do_brille=do_sandwich=do_bauchbinde=1;

do_case=0;


symmstring[0] = 0;       /* TH - Filekennung loeschen */

if (argc<2) exit(93);


knotenzahl=atoi(argv[1]);
if ((knotenzahl%2) || (knotenzahl<20)) { fprintf(stderr,"Impossible vertex number. \n"); exit(94); }

min_sechsecke=max_sechsecke=sechsecke=(knotenzahl-20)/2;


if (knotenzahl >= leer) { fprintf(stderr,"Number of vertices too large for the data-types used. \n"); exit(95); }
if (aussen >= leer) { fprintf(stderr,"Definition of \"S\" too large for the data-types used. \n"); exit(96); }
if (S+12 > FL_MAX) { fprintf(stderr,"Definition of \"S\" too large for the data-types used for FLAECHENTYP. \n");
		     exit(97); }

if (sechsecke > S) { fprintf(stderr,"Fix the constant \"S\" to at least %d\n",sechsecke); exit(98); }

codenumber=listenlaenge=0;

for (i=2; i<argc; i++)
    switch (argv[i][0])
      {
      case 'i': { if (strcmp(argv[i],"ipr")==0) IPR=1;
		    else { fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(99); }
		  break; }

      case 'h': { if (strcmp(argv[i],"hexspi")==0) hexspi=1;
		    else { fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(100); }
		  break; }

      case 's': { if (strcmp(argv[i],"start")==0)
		    { i++; puffer=atoi(argv[i]); 
		      if ((puffer%2) || (puffer<20)) 
			{ fprintf(stderr,"Impossible vertex number to start. \n"); exit(101); }
		      min_sechsecke=(puffer-20)/2; }
                    else
		      if (strcmp(argv[i],"stdout")==0) to_stdout=1;
                    else
		      if (strcmp(argv[i],"spistat")==0) spistat=1;
                    else
		      if (strcmp(argv[i],"spiralcheck")==0) spiralcheck=1;
                    else
                      if (strcmp(argv[i],"symstat")==0) symstat=1;   /* TH */
                    else
                      if (strcmp(argv[i],"symm")==0) {               /* TH */
                        int j=28, ii;
                        BOOL gefunden = False;
 			symstat=1;                /* immer -- kostet ja nichts extra */
                        i++;
                        if (i<argc) {
                          while (j>0 && !gefunden) {
                            for (ii=0; ii<=3; ii++) {
                              name[ii] = (symm_name[j][ii]==' ') ? '\0' : symm_name[j][ii]; 
                            }
                            if (strcmp(argv[i],name)==0) {      /* Symmetrie j gefunden */
                              gefunden = True;
                              if (!vergleiche_symm(j))   /* Symmetrie noch nicht in Liste */
                                {symm[symm_len++] = j;  
                                 strcat(symmstring,(char *)"_"); strcat(symmstring,name);}
                            } 
                            j--;
                          }
                        }
                        if (!gefunden) 
                           {fprintf(stderr,"Unknown symmetry identifier. \n"); exit(102);}
                        break;
                      }  /* if */ 
		    else { fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(103); }
		  break; }
      case 'c': { if (strcmp(argv[i],"code")==0)
		    { i++; codenumber=atoi(argv[i]); }
		  else
		    if (strcmp(argv[i],"case")==0)
		    { i++; do_case=atoi(argv[i]);
		      switch (do_case)
			{ case 1: { do_brille=do_sandwich=0; do_bauchbinde=1; break; }
			  case 2: { do_brille=1; do_sandwich=do_bauchbinde=0; break; }
			  case 3: { do_brille=do_bauchbinde=0; do_sandwich=1; break; }
			 default: { fprintf(stderr,"No such case !\n"); exit(104); }
			}
		      }
		    else { fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(105); }
		  break; }
      case 'p': { if (strcmp(argv[i],"pid")==0) {fprintf(stdout,"%d\n",getpid());  fflush(stdout);}
                  else {fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(119);}
                  break;
                }   
      case 'q': { if (strcmp(argv[i],"quiet")==0) quiet=1;
                  else {fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(120);}
                  break;
                }   
      case 'l': { if (strcmp(argv[i],"list")==0)
		    { i++; listenlaenge=atoi(argv[i]); }
		  else if (strcmp(argv[i],"logerr")==0) {
		    logfile = stderr;
		    separate_logfile = 0;
		  }
		  else { fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(106); }
		  break; }

      case 'm': { if (strcmp(argv[i],"mod")==0)
		    { i++; rest=atoi(argv[i]); i++; mod=atoi(argv[i]);
		      if ((mod<=0) || (rest<0) || (rest>=mod))
		        { fprintf(stderr,"Bad values for option mod \n"); exit(0); }
		    }
		    else { fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(106); }
		  break; }



      default: { fprintf(stderr,"Nonidentified option: %s \n",argv[i]); exit(107); }
      }


switch (codenumber)
  {
  case 0: break;
  case 1:
  case 8: { for (i=20+(2*min_sechsecke); i<=knotenzahl; i+=2)
	      { if (IPR) sprintf(strpuf,"Full_codes_%d_ipr",i);
		  else sprintf(strpuf,"Full_codes_%d",i);
		if (do_case) { sprintf(strpuf2,"_c%d",do_case); strcat(strpuf,strpuf2); }
		if (mod) { sprintf(strpuf2,"_m_%d_%d",rest,mod); strcat(strpuf,strpuf2); }
                if (symm_len>0)    {strcat(strpuf,symmstring);}
		if (to_stdout) fil[i]=stdout; else fil[i]=fopen(strpuf,"wb");
		if (!to_stdout) write_header_fil[i]=1;
	        if (fil[i]==nil) { fprintf(stderr,"Can not open file %s. \n",strpuf); exit(109);}
	      }
	    break; }
  case 2: { for (i=20+(2*min_sechsecke); i<=knotenzahl; i+=2)
	      { if (IPR) sprintf(strpuf,"Spiral_codes_%d_ipr",i);
		  else sprintf(strpuf,"Spiral_codes_%d",i);
		if (do_case) { sprintf(strpuf2,"_c%d",do_case); strcat(strpuf,strpuf2); }
		if (mod) { sprintf(strpuf2,"_m_%d_%d",rest,mod); strcat(strpuf,strpuf2); }
                if (symm_len>0)    {strcat(strpuf,symmstring);}
		if (to_stdout) fil[i]=stdout; else fil[i]=fopen(strpuf,"wb");
		if (!to_stdout) write_header_fil[i]=1;
	        if (fil[i]==nil) { fprintf(stderr,"Can not open file %s. \n",strpuf); exit(110);}
	      }
	    spiralcheck=1;
	    last_code[0]=FL_MAX;
	    break; }
  case 3: { spiralcheck=1;
            if (listenlaenge==0) listenlaenge=2000;
            for (i=20+(2*min_sechsecke); i<=knotenzahl; i+=2)
	      { (codeliste[i].code)[0]=0;
		if (IPR) sprintf(strpuf,"Spiral_codes_%d_ipr",i);
		  else sprintf(strpuf,"Spiral_codes_%d",i);
		if (do_case) { sprintf(strpuf2,"_c%d",do_case); strcat(strpuf,strpuf2); }
		if (mod) { sprintf(strpuf2,"_m_%d_%d",rest,mod); strcat(strpuf,strpuf2); }
                if (symm_len>0)    {strcat(strpuf,symmstring);}
		if (to_stdout) fil[i]=stdout; else fil[i]=fopen(strpuf,"wb");
                if (!to_stdout) write_header_fil[i]=1;
	        if (fil[i]==nil) { fprintf(stderr,"Can not open file %s. \n",strpuf); exit(111);}
		lastcode[i]=(FLAECHENTYP **)malloc(sizeof(FLAECHENTYP *));
		if (lastcode[i] ==nil) { fprintf(stderr,"Can not get memory for lastcode. \n"); exit(112); }
		(*(lastcode[i]))=(FLAECHENTYP *)malloc(sizeof(FLAECHENTYP)*12);
		(*(lastcode[i]))[0]=FL_MAX;
	      }
	    break; }
  case 4: spiralcheck=1; break; /* Nur nicht-spiral-codes schreiben */
  case 5: { spiralcheck=1;
            for (i=20+(2*min_sechsecke); i<=knotenzahl; i+=2)
	      { if (IPR) sprintf(strpuf,"Full_codes_%d_ipr",i);
		  else sprintf(strpuf,"Full_codes_%d",i);
		if (do_case) { sprintf(strpuf2,"_c%d",do_case); strcat(strpuf,strpuf2); }
		if (mod) { sprintf(strpuf2,"_m_%d_%d",rest,mod); strcat(strpuf,strpuf2); }
                if (symm_len>0)    {strcat(strpuf,symmstring);}
		if (to_stdout) fil[i]=stdout; else fil[i]=fopen(strpuf,"wb");
	        if (fil[i]==nil) { fprintf(stderr,"Can not open file %s. \n",strpuf); exit(113);}
                if (!to_stdout) write_header_fil[i]=1;
	      }
	    break; }

  case 6: { break; }

  case 7: { break; }

  default: { fprintf(stderr,"No coding number %d. \n", codenumber); exit(114); }
  }

if (hexspi && !spiralcheck) 
  { fprintf(stderr,"The option \"hexspi\" must be used together with some code involving spiral checking \n");
    exit(115); }

if (spistat && (min_sechsecke != max_sechsecke)) 
  { fprintf(stderr,"The option \"spistat\" must be used only for fullerenes of ONE size \n");
    exit(116); }

if (spistat) for (i=0; i<=12*max_sechsecke+120; i++) spiralnumbers[i]=0;


if (IPR)
  {  if (min_sechsecke==max_sechsecke) sprintf(logfilename,"Full_gen_%d_ipr",knotenzahl);
    else sprintf(logfilename,"Full_gen_%d_%d_ipr",knotenzahl,(2*min_sechsecke)+20); }
else
  {  if (min_sechsecke==max_sechsecke) sprintf(logfilename,"Full_gen_%d",knotenzahl);
  else sprintf(logfilename,"Full_gen_%d_%d",knotenzahl,(2*min_sechsecke)+20); }

  if (do_case) { sprintf(strpuf2,"_c%d",do_case); strcat(logfilename,strpuf2); }
  if (mod) { sprintf(strpuf2,"_m_%d_%d",rest,mod); strcat(logfilename,strpuf2); }
  if (spiralcheck) { sprintf(no_spiral_filename,"No_spiral_");
		     strcat(no_spiral_filename,logfilename+9);
		     sprintf(strdummy,"rm %s",no_spiral_filename);
		     if (!stat(strdummy,&buf)) {
                         if(system (strdummy)==-1){
                             fprintf(stderr,"Could not execute system call.\n");
                         }
                     }
		     sprintf(no_penta_spiral_filename,"No_pentagon_spiral_");
		     strcat(no_penta_spiral_filename,logfilename+9);
		     sprintf(strdummy,"rm %s",no_penta_spiral_filename);
		     if (!stat(strdummy,&buf)) {
                         if(system (strdummy)==-1){
                             fprintf(stderr,"Could not execute system call.\n");
                         }
                     }
		      }
  if (hexspi) { sprintf(no_hexa_spiral_filename,"No_hexagon_spiral_");
		strcat(no_hexa_spiral_filename,logfilename+9);
		sprintf(strdummy,"rm %s",no_hexa_spiral_filename);
		if (!stat(strdummy,&buf)) {
                     if(system (strdummy)==-1){
                         fprintf(stderr,"Could not execute system call.\n");
                     }
                }
	      }

if (!quiet)
  {
    strcat(logfilename,".log");
    if (separate_logfile) logfile=fopen(logfilename,"w");
    if (logfile==nil) { fprintf(stderr,"Can not open file %s. \n",logfilename); exit(118);}
    fprintf(logfile,"Minimal vertex number: %d \n",(2*min_sechsecke)+20);
    fprintf(logfile,"Maximal vertex number: %d \n",knotenzahl);
    fprintf(logfile,"Code_type: %d \n",codenumber);
    if (codenumber==3) fprintf(logfile,"List length: %d \n",listenlaenge);
    if (separate_logfile) fclose(logfile);
  }


initialize_list();

baue_patches(sechsecke); 
#ifndef NOTIMES
times(&TMS);
savetime= TMS.tms_utime;
if (!quiet) 
  { fprintf(stderr,"Time for generating the patches: %.1f seconds \n",(double)savetime/time_factor);
    if (separate_logfile) {
      logfile=fopen(logfilename,"a");
      fprintf(logfile,"Time for generating the patches: %.1f seconds \n",(double)savetime/time_factor);
      fclose(logfile);
    }
  }
#endif //NOTIMES

if (do_bauchbinde)
{
bauchbinde(min_sechsecke,max_sechsecke);
#ifndef NOTIMES
times(&TMS);
buffertime= TMS.tms_utime;
if (!quiet) 
  { fprintf(stderr,"Time for case 1 (Jordan-Curve Petrie Path): %.1f seconds \n",(double)(buffertime-savetime)/time_factor);
    if (separate_logfile) {
      logfile=fopen(logfilename,"a");
      fprintf(logfile,"Time for case 1 (Jordan-Curve Petrie Path): %.1f seconds \n",(double)(buffertime-savetime)/time_factor);
      fclose(logfile);
    }
  }
savetime=buffertime;
#endif //NOTIMES
}

if (do_brille)
{
brille(min_sechsecke,max_sechsecke);
#ifndef NOTIMES
times(&TMS);
buffertime= TMS.tms_utime;
if (!quiet) 
  { fprintf(stderr,"Time for case 2 (Dumb-bell): %.1f seconds \n",(double)(buffertime-savetime)/time_factor);
    if (separate_logfile) {
      logfile=fopen(logfilename,"a");
      fprintf(logfile,"Time for case 2 (Dumb-bell): %.1f seconds \n",(double)(buffertime-savetime)/time_factor);
      fclose(logfile);
    }
    savetime=buffertime;
  }
#endif //NOTIMES
}

if (do_sandwich)
{
sandwich(min_sechsecke,max_sechsecke);
#ifndef NOTIMES
times(&TMS);
buffertime= TMS.tms_utime;
if (!quiet) 
  { fprintf(stderr,"Time for case 3 (Sandwich): %.1f seconds \n\n",(double)(buffertime-savetime)/time_factor);
    if (separate_logfile) {
      logfile=fopen(logfilename,"a");
      fprintf(logfile,"Time for case 3 (Sandwich): %.1f seconds \n\n",(double)(buffertime-savetime)/time_factor);
      fclose(logfile);
    }
  }
#endif //NOTIMES
}

if (codenumber==3) 
  for (i=20+(2*min_sechsecke); i<=knotenzahl; i++) ausgabe(codeliste+i,i,lastcode[i]);


if (!quiet) 
 { 
   fprintf(stderr,"MAPLIST: number of patches: %d\n",mapliste.total_maps);
   fprintf(stderr,"BBLIST: number of items in list: %d  number of patches: %d\n\n",bbliste.total_items,bbliste.total_maps);
   for (i=20+(2*min_sechsecke); i<=20+(2*max_sechsecke); i+=2)
     fprintf(stderr,"Generated %lld maps on %d vertices -- reduced to %lld non-isomorphic maps. \n",non_iso_graphenzahl[i],i,graphenzahl[i]);
   if (spistat) for (i=0; i<=12*max_sechsecke+120; i++) 
     if (spiralnumbers[i]) fprintf(stderr,"Fullerenes with %d spirals: %d \n",i,spiralnumbers[i]);
   if (spiralcheck) fprintf(stderr,"Graphs without a spiral starting at a pentagon: %d \n",no_penta_spiral);
   if (hexspi) fprintf(stderr,"Graphs without a spiral starting at a hexagon: %d \n",no_hexa_spiral);
   if (symstat) schreibe_symmetriestatistik();
#ifndef NOTIMES 
  fprintf(stderr,"\nTotal generation time: %.1f seconds \n",(double)buffertime/time_factor);
#endif //NOTIMES   
   fprintf(stderr,"end of program\n");
   
   if (separate_logfile) {
     logfile=fopen(logfilename,"a");
     fprintf(logfile,"MAPLIST: number of patches: %d\n",mapliste.total_maps);
     fprintf(logfile,"BBLIST: number of items in list: %d  number of patches: %d\n\n",bbliste.total_items,bbliste.total_maps);
     for (i=20+(2*min_sechsecke); i<=20+(2*max_sechsecke); i+=2)
       fprintf(logfile,"Generated %lld maps on %d vertices -- reduced to %lld non-isomorphic maps. \n",non_iso_graphenzahl[i],i,graphenzahl[i]);
     if (spistat) for (i=0; i<=12*max_sechsecke+120; i++) 
       if (spiralnumbers[i]) fprintf(logfile,"Fullerenes with %d spirals: %d \n",i,spiralnumbers[i]);
     if (spiralcheck) fprintf(logfile,"Graphs without a spiral starting at a pentagon: %d \n",no_penta_spiral);
     if (hexspi) fprintf(logfile,"Graphs without a spiral starting at a hexagon: %d \n",no_hexa_spiral);
     if (symstat) {    /* schreibe Symmetriestatistik */
       int j=0;
       fprintf(logfile,"Symmetries:\n");
       for (i=1; i<=28; i++) {
	 if (symm_anz[i]>0) {
	   fprintf(logfile,"  %s: %10d ",symm_name[i],symm_anz[i]); 
	   j++;
	   if (j%4==0) {fprintf(logfile,"\n");}
	 }
       }
       if (j%4) {fprintf(logfile,"\n");}
     }        
#ifndef NOTIMES
     fprintf(logfile,"\nTotal generation time: %.1f seconds \n",(double)buffertime/time_factor);
#endif //NOTIMES     
     fprintf(logfile,"end of program\n");
   }
 }

return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rsi, %r15
movl %edi, %ebx
leaq 0x124f1(%rip), %rdi     # 0x20b38
movl $0x1220, %edx           # imm = 0x1220
xorl %esi, %esi
callq 0x1080
leaq 0xf08e(%rip), %rdi      # 0x1d6e8
movl $0x1220, %edx           # imm = 0x1220
xorl %esi, %esi
callq 0x1080
movb $0x1, %al
movb %al, 0x1226e(%rip)      # 0x208dc
movb %al, 0x11dbc(%rip)      # 0x20430
movb %al, 0x11db7(%rip)      # 0x20431
movb $0x0, 0x136df(%rip)     # 0x21d60
movl %ebx, 0x14(%rsp)
cmpl $0x1, %ebx
jle 0xf7e4
movq 0x8(%r15), %rdi
callq 0x1140
movl %eax, 0x13737(%rip)     # 0x21dd4
cmpl $0x14, %eax
jl 0xf7ee
movl %eax, %ecx
andl $0x1, %ecx
jne 0xf7ee
leal -0x14(%rax), %ecx
movl %ecx, %ebp
shrl %ebp
movl %ebp, 0x1221a(%rip)     # 0x208d8
movl %ebp, 0x13714(%rip)     # 0x21dd8
cmpl $0xfffe, %eax           # imm = 0xFFFE
jae 0xf7f3
cmpl $0x119, %ecx            # imm = 0x119
jae 0xf7f8
xorl %r13d, %r13d
movl %r13d, 0x10223(%rip)    # 0x1e908
movl %r13d, 0x9d60(%rip)     # 0x1844c
movl $0x0, %r14d
cmpl $0x2, 0x14(%rsp)
je 0xf0d5
movl %ebp, 0x10(%rsp)
movl $0x2, %r12d
movl $0x1, 0x18(%rsp)
movl $0x0, 0x4(%rsp)
movq %r15, 0x8(%rsp)
movslq %r12d, %r14
movq (%r15,%r14,8), %rbx
movzbl (%rbx), %eax
addl $-0x63, %eax
cmpl $0x10, %eax
ja 0xf7af
leaq 0x1acf(%rip), %rcx      # 0x10208
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
leaq 0x2526(%rip), %rsi      # 0x10c72
callq 0x10a0
testl %eax, %eax
je 0xeadf
movq %rbx, %rdi
leaq 0x2514(%rip), %rsi      # 0x10c77
callq 0x10a0
testl %eax, %eax
jne 0xf7dc
incl %r12d
movq 0x8(%r15,%r14,8), %rdi
callq 0x1140
cmpl $0x3, %eax
je 0xeb1c
cmpl $0x2, %eax
je 0xeafd
cmpl $0x1, %eax
jne 0xf831
xorl %eax, %eax
movb %al, 0x11c90(%rip)      # 0x20430
movb %al, 0x11c8b(%rip)      # 0x20431
movb $0x1, 0x1212f(%rip)     # 0x208dc
movl $0x1, 0x4(%rsp)
jmp 0xeb54
movq %rbx, %rdi
leaq 0x24de(%rip), %rsi      # 0x10ca2
callq 0x10a0
testl %eax, %eax
jne 0xf792
movq 0x8(%r15,%r14,8), %rdi
callq 0x1140
movl %eax, %ebx
movl %eax, 0x69b9(%rip)      # 0x1519c
movq 0x10(%r15,%r14,8), %rdi
callq 0x1140
movl %eax, 0x69a5(%rip)      # 0x15198
testl %eax, %eax
jle 0xf79a
testl %ebx, %ebx
js 0xf79a
cmpl %eax, %ebx
jge 0xf79a
addl $0x2, %r12d
jmp 0xeb54
movq %rbx, %rdi
leaq 0x246e(%rip), %rsi      # 0x10c8c
callq 0x10a0
testl %eax, %eax
jne 0xf78a
movq 0x67a6(%rip), %r14      # 0x14fd8
movq (%r14), %rbx
callq 0x1040
movq %rbx, %rdi
leaq 0x1f48(%rip), %rsi      # 0x1078c
movl %eax, %edx
xorl %eax, %eax
callq 0x10b0
movq (%r14), %rdi
callq 0x10f0
jmp 0xeb54
movq %rbx, %rdi
leaq 0x25bd(%rip), %rsi      # 0x10e21
callq 0x10a0
testl %eax, %eax
jne 0xf79f
movb $0x1, 0x6919(%rip)      # 0x15191
jmp 0xeb54
movq %rbx, %rdi
leaq 0x2379(%rip), %rsi      # 0x10c00
callq 0x10a0
testl %eax, %eax
je 0xea99
movq %rbx, %rdi
leaq 0x238d(%rip), %rsi      # 0x10c2b
callq 0x10a0
testl %eax, %eax
je 0xeaf4
movq %rbx, %rdi
leaq 0x237d(%rip), %rsi      # 0x10c32
callq 0x10a0
testl %eax, %eax
je 0xeb3b
movq %rbx, %rdi
leaq 0x236e(%rip), %rsi      # 0x10c3a
callq 0x10a0
testl %eax, %eax
je 0xeb44
movq %rbx, %rdi
leaq 0x2363(%rip), %rsi      # 0x10c46
callq 0x10a0
testl %eax, %eax
je 0xeb4d
movq %rbx, %rdi
leaq 0x2354(%rip), %rsi      # 0x10c4e
callq 0x10a0
testl %eax, %eax
jne 0xf83b
movb $0x1, 0x6892(%rip)      # 0x151a0
incl %r12d
cmpl 0x14(%rsp), %r12d
jge 0xf77d
movl 0x692d(%rip), %r15d     # 0x15250
movslq %r12d, %rax
movq %rax, 0x20(%rsp)
movl $0x1c, %r14d
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rbp
leaq 0x679a(%rip), %rax      # 0x150e0
leaq (%rax,%r14,4), %r13
movd (%r13), %xmm0
movdqa %xmm0, %xmm1
pcmpeqb 0x1714(%rip), %xmm1     # 0x10070
pandn %xmm0, %xmm1
movd %xmm1, 0x1c(%rsp)
movq %rbp, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x10a0
movl %eax, %ebx
testl %eax, %eax
je 0xe993
cmpq $0x2, %r14
jb 0xf77d
decq %r14
addq $-0x4, %r13
testl %ebx, %ebx
jne 0xe94a
jmp 0xf77d
testl %r15d, %r15d
leaq 0x6893(%rip), %rdx      # 0x15230
jle 0xe9b2
movl %r15d, %eax
xorl %ecx, %ecx
cmpb %r14b, (%rcx,%rdx)
je 0xe9e9
incq %rcx
cmpq %rcx, %rax
jne 0xe9a4
leal 0x1(%r15), %ebp
movl %ebp, 0x6894(%rip)      # 0x15250
movslq %r15d, %rax
movb %r14b, (%rax,%rdx)
leaq 0x13396(%rip), %r15     # 0x21d60
movq %r15, %rdi
callq 0x1060
movw $0x5f, (%rax,%r15)
movq %r15, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x1150
movl %ebp, %r15d
cmpq $0x2, %r14
jb 0xe9fa
decq %r14
testl %ebx, %ebx
jne 0xe931
testl %ebx, %ebx
je 0xeb54
jmp 0xf77d
movq %rbx, %rdi
leaq 0x2285(%rip), %rsi      # 0x10c96
callq 0x10a0
testl %eax, %eax
je 0xeaca
movq %rbx, %rdi
leaq 0x2273(%rip), %rsi      # 0x10c9b
callq 0x10a0
movq 0x65c4(%rip), %rcx      # 0x14ff8
movq (%rcx), %rdi
testl %eax, %eax
jne 0xf7c1
movq %rdi, 0x1339a(%rip)     # 0x21de0
movl $0x0, 0x18(%rsp)
jmp 0xeb54
movq %rbx, %rdi
leaq 0x219c(%rip), %rsi      # 0x10bf9
callq 0x10a0
testl %eax, %eax
jne 0xf7a7
movb $0x1, 0x6722(%rip)      # 0x15193
jmp 0xeb54
movq %rbx, %rdi
leaq 0x2210(%rip), %rsi      # 0x10c90
callq 0x10a0
testl %eax, %eax
jne 0xf782
movb $0x1, 0x66fc(%rip)      # 0x15190
jmp 0xeb54
movq 0x8(%r15,%r14,8), %rdi
callq 0x1140
cmpl $0x14, %eax
jl 0xf827
movl %eax, %ecx
andl $0x1, %ecx
jne 0xf827
incl %r12d
addl $-0x14, %eax
shrl %eax
movl %eax, 0x13313(%rip)     # 0x21dd8
jmp 0xeb54
incl %r12d
movq 0x8(%r15,%r14,8), %rdi
callq 0x1140
movl %eax, 0xfe2b(%rip)      # 0x1e908
jmp 0xeb54
incl %r12d
movq 0x8(%r15,%r14,8), %rdi
callq 0x1140
movl %eax, 0x995a(%rip)      # 0x1844c
jmp 0xeb54
movb $0x1, 0x6697(%rip)      # 0x15192
jmp 0xeb54
movb $0x1, 0x1192d(%rip)     # 0x20431
xorl %eax, %eax
movb %al, 0x11dd0(%rip)      # 0x208dc
movb %al, 0x1191e(%rip)      # 0x20430
movl $0x2, 0x4(%rsp)
jmp 0xeb54
xorl %eax, %eax
movb %al, 0x11db8(%rip)      # 0x208dc
movb %al, 0x11907(%rip)      # 0x20431
movb $0x1, 0x118ff(%rip)     # 0x20430
movl $0x3, 0x4(%rsp)
jmp 0xeb54
movb $0x1, 0x6652(%rip)      # 0x15194
jmp 0xeb54
movb $0x1, 0x664a(%rip)      # 0x15195
jmp 0xeb54
movb $0x1, 0x664c(%rip)      # 0x151a0
incl %r12d
cmpl 0x14(%rsp), %r12d
movq 0x8(%rsp), %r15
jl 0xe71c
movl 0x98df(%rip), %edi      # 0x1844c
cmpl $0x0, 0x18(%rsp)
sete %r13b
cmpq $0x8, %rdi
ja 0xf843
leaq 0x16c5(%rip), %rax      # 0x1024c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
movl 0x10(%rsp), %ebp
jmpq *%rcx
movslq 0x1323d(%rip), %rbx     # 0x21dd8
addq %rbx, %rbx
leal 0x14(%rbx), %eax
cmpl 0x1322d(%rip), %eax     # 0x21dd4
jg 0xf0d0
movl %r13d, 0x8(%rsp)
addq $0x14, %rbx
leaq 0x2117(%rip), %rbp      # 0x10cd4
leaq 0x20fe(%rip), %r13      # 0x10cc2
leaq 0x50(%rsp), %r14
leaq 0x8650(%rip), %r15      # 0x17220
leaq 0x1f0(%rsp), %r12
cmpb $0x0, 0x65b2(%rip)      # 0x15191
movq %r13, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x4(%rsp), %edx
testl %edx, %edx
je 0xec16
movq %r12, %rdi
leaq 0x20de(%rip), %rsi      # 0x10ce2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x657c(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xec42
movl 0x6576(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x20b7(%rip), %rsi      # 0x10ce7
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x6607(%rip)      # 0x15250
jle 0xec5a
movq %r14, %rdi
leaq 0x1310b(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x6531(%rip)      # 0x15192
je 0xec73
movq 0x636e(%rip), %rax      # 0x14fd8
movq (%rax), %rax
movq %rax, (%r15,%rbx,8)
jmp 0xec9d
movq %r14, %rdi
leaq 0x2073(%rip), %rsi      # 0x10cf0
callq 0x1120
cmpb $0x0, 0x6509(%rip)      # 0x15192
movq %rax, (%r15,%rbx,8)
jne 0xec9d
leaq 0x988a(%rip), %rcx      # 0x18520
movl $0x1, (%rcx,%rbx,4)
testq %rax, %rax
je 0xf7b7
addq $0x2, %rbx
movslq 0x13123(%rip), %rax     # 0x21dd4
cmpq %rax, %rbx
jle 0xebd8
jmp 0xf0c7
movb $0x1, 0x64cf(%rip)      # 0x15195
jmp 0xf0d0
movl %r13d, 0x8(%rsp)
movslq 0x13101(%rip), %rbx     # 0x21dd8
addq %rbx, %rbx
leal 0x14(%rbx), %eax
cmpl 0x130f1(%rip), %eax     # 0x21dd4
jg 0xedf1
addq $0x14, %rbx
leaq 0x202b(%rip), %rbp      # 0x10d1f
leaq 0x2010(%rip), %r13      # 0x10d0b
leaq 0x50(%rsp), %r14
leaq 0x8519(%rip), %r15      # 0x17220
leaq 0x1f0(%rsp), %r12
cmpb $0x0, 0x647b(%rip)      # 0x15191
movq %r13, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x4(%rsp), %edx
testl %edx, %edx
je 0xed4d
movq %r12, %rdi
leaq 0x1fa7(%rip), %rsi      # 0x10ce2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x6445(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xed79
movl 0x643f(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x1f80(%rip), %rsi      # 0x10ce7
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x64d0(%rip)      # 0x15250
jle 0xed91
movq %r14, %rdi
leaq 0x12fd4(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x63fa(%rip)      # 0x15192
je 0xedaa
movq 0x6237(%rip), %rax      # 0x14fd8
movq (%rax), %rax
movq %rax, (%r15,%rbx,8)
jmp 0xedd4
movq %r14, %rdi
leaq 0x1f3c(%rip), %rsi      # 0x10cf0
callq 0x1120
cmpb $0x0, 0x63d2(%rip)      # 0x15192
movq %rax, (%r15,%rbx,8)
jne 0xedd4
leaq 0x9753(%rip), %rcx      # 0x18520
movl $0x1, (%rcx,%rbx,4)
testq %rax, %rax
je 0xf804
addq $0x2, %rbx
movslq 0x12fec(%rip), %rax     # 0x21dd4
cmpq %rax, %rbx
jle 0xed0f
movb $0x1, 0x639d(%rip)      # 0x15195
movb $-0x1, 0xa035(%rip)     # 0x18e34
jmp 0xf0c7
movb $0x1, 0x638a(%rip)      # 0x15195
cmpl $0x0, 0xfaf6(%rip)      # 0x1e908
jne 0xee1e
movl $0x7d0, 0xfaea(%rip)    # imm = 0x7D0
movslq 0x12fb3(%rip), %rax     # 0x21dd8
addq %rax, %rax
leal 0x14(%rax), %ecx
cmpl 0x12fa3(%rip), %ecx     # 0x21dd4
jg 0xf0d0
movl %r13d, 0x8(%rsp)
leaq 0x14(%rax), %rbx
shlq $0x5, %rax
leaq 0x9ff5(%rip), %rcx      # 0x18e40
leaq (%rax,%rcx), %r13
addq $0x280, %r13            # imm = 0x280
leaq 0x50(%rsp), %r14
leaq 0xfaae(%rip), %r15      # 0x1e910
leaq 0x1f0(%rsp), %r12
cmpb $0x0, 0x6320(%rip)      # 0x15191
movb $0x0, (%r13)
leaq 0x1e8e(%rip), %rsi      # 0x10d0b
leaq 0x1e9b(%rip), %rax      # 0x10d1f
cmoveq %rax, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x4(%rsp), %edx
testl %edx, %edx
je 0xeeb8
movq %r12, %rdi
leaq 0x1e3c(%rip), %rsi      # 0x10ce2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x62da(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xeee4
movl 0x62d4(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x1e15(%rip), %rsi      # 0x10ce7
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x6365(%rip)      # 0x15250
jle 0xeefc
movq %r14, %rdi
leaq 0x12e69(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x628f(%rip)      # 0x15192
je 0xef1c
movq 0x60cc(%rip), %rax      # 0x14fd8
movq (%rax), %rax
leaq 0x830a(%rip), %rcx      # 0x17220
movq %rax, (%rcx,%rbx,8)
jmp 0xef4d
movq %r14, %rdi
leaq 0x1dca(%rip), %rsi      # 0x10cf0
callq 0x1120
cmpb $0x0, 0x6260(%rip)      # 0x15192
leaq 0x82e7(%rip), %rcx      # 0x17220
movq %rax, (%rcx,%rbx,8)
jne 0xef4d
leaq 0x95da(%rip), %rcx      # 0x18520
movl $0x1, (%rcx,%rbx,4)
testq %rax, %rax
je 0xf818
movl $0x8, %edi
callq 0x10e0
movq %rax, (%r15,%rbx,8)
testq %rax, %rax
je 0xf822
movq %rax, %rbp
movl $0xc, %edi
callq 0x10e0
movq %rax, (%rbp)
movb $-0x1, (%rax)
addq $0x2, %rbx
movslq 0x12e48(%rip), %rax     # 0x21dd4
addq $0x40, %r13
cmpq %rax, %rbx
jle 0xee6a
jmp 0xf0c7
movb $0x1, 0x61f0(%rip)      # 0x15195
movslq 0x12e2c(%rip), %rbx     # 0x21dd8
addq %rbx, %rbx
leal 0x14(%rbx), %eax
cmpl 0x12e1c(%rip), %eax     # 0x21dd4
jg 0xf0d0
movl %r13d, 0x8(%rsp)
addq $0x14, %rbx
leaq 0x1d06(%rip), %rbp      # 0x10cd4
leaq 0x1ced(%rip), %r13      # 0x10cc2
leaq 0x50(%rsp), %r14
leaq 0x823f(%rip), %r15      # 0x17220
leaq 0x1f0(%rsp), %r12
cmpb $0x0, 0x61a1(%rip)      # 0x15191
movq %r13, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x4(%rsp), %edx
testl %edx, %edx
je 0xf027
movq %r12, %rdi
leaq 0x1ccd(%rip), %rsi      # 0x10ce2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x616b(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xf053
movl 0x6165(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x1ca6(%rip), %rsi      # 0x10ce7
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x61f6(%rip)      # 0x15250
jle 0xf06b
movq %r14, %rdi
leaq 0x12cfa(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x6120(%rip)      # 0x15192
je 0xf080
movq 0x5f5d(%rip), %rax      # 0x14fd8
movq (%rax), %rax
jmp 0xf08f
movq %r14, %rdi
leaq 0x1c66(%rip), %rsi      # 0x10cf0
callq 0x1120
movq %rax, (%r15,%rbx,8)
testq %rax, %rax
je 0xf80e
cmpb $0x0, 0x60ef(%rip)      # 0x15192
jne 0xf0b3
leaq 0x9474(%rip), %rax      # 0x18520
movl $0x1, (%rax,%rbx,4)
addq $0x2, %rbx
movslq 0x12d16(%rip), %rax     # 0x21dd4
cmpq %rax, %rbx
jle 0xefe9
movl 0x10(%rsp), %ebp
movl 0x8(%rsp), %r13d
movl 0x4(%rsp), %r14d
cmpb $0x0, 0x60b7(%rip)      # 0x15193
je 0xf0eb
cmpb $0x0, 0x60b0(%rip)      # 0x15195
je 0xf7ff
cmpb $0x0, 0x60a2(%rip)      # 0x15194
je 0xf132
movl 0x12cde(%rip), %eax     # 0x21dd8
cmpl 0x117d8(%rip), %eax     # 0x208d8
jne 0xf82c
cmpl $-0xa, %eax
jl 0xf132
leal (%rax,%rax,2), %eax
leal 0x78(,%rax,4), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
leaq 0x4(,%rax,4), %rdx
leaq 0x64c5(%rip), %rdi      # 0x155f0
xorl %esi, %esi
callq 0x1080
cmpb $0x0, 0x6058(%rip)      # 0x15191
movl 0x12c99(%rip), %eax     # 0x21dd8
movl 0x11793(%rip), %ecx     # 0x208d8
movl 0x12c89(%rip), %edx     # 0x21dd4
je 0xf161
cmpl %ecx, %eax
jne 0xf17c
leaq 0x12c98(%rip), %rdi     # 0x21df0
leaq 0x1ca3(%rip), %rsi      # 0x10e02
jmp 0xf173
cmpl %ecx, %eax
jne 0xf193
leaq 0x12c84(%rip), %rdi     # 0x21df0
leaq 0x1cb2(%rip), %rsi      # 0x10e25
xorl %eax, %eax
callq 0x1160
jmp 0xf1af
leal 0x14(,%rax,2), %ecx
leaq 0x12c66(%rip), %rdi     # 0x21df0
leaq 0x1c81(%rip), %rsi      # 0x10e12
jmp 0xf1a8
leal 0x14(,%rax,2), %ecx
leaq 0x12c4f(%rip), %rdi     # 0x21df0
leaq 0x1c89(%rip), %rsi      # 0x10e31
xorl %eax, %eax
callq 0x1160
testl %r14d, %r14d
je 0xf1df
leaq 0x1b27(%rip), %rsi      # 0x10ce2
leaq 0x1f0(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1160
leaq 0x12c19(%rip), %rdi     # 0x21df0
movq %rbx, %rsi
callq 0x1150
movl 0x5fb3(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xf217
movl 0x5fad(%rip), %edx      # 0x1519c
leaq 0x1af1(%rip), %rsi      # 0x10ce7
leaq 0x1f0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
leaq 0x12be1(%rip), %rdi     # 0x21df0
movq %rbx, %rsi
callq 0x1150
cmpb $0x0, 0x5f77(%rip)      # 0x15195
je 0xf311
movabsq $0x61726970735f6f4e, %rax # imm = 0x61726970735F6F4E
movq %rax, 0x921b(%rip)      # 0x18450
movl $0x5f6c61, 0x9218(%rip) # imm = 0x5F6C61
leaq 0x920a(%rip), %rbx      # 0x18450
leaq 0x12bac(%rip), %rsi     # 0x21df9
movq %rbx, %rdi
callq 0x1150
leaq 0x1bef(%rip), %rsi      # 0x10e4b
leaq 0x120(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
leaq 0x2b8(%rsp), %rsi
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0xf29b
leaq 0x120(%rsp), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0xf75f
movdqu 0x1bce(%rip), %xmm0     # 0x10e71
movdqa %xmm0, 0x61a5(%rip)     # 0x15450
movl $0x5f6c61, 0x61ab(%rip) # imm = 0x5F6C61
leaq 0x6194(%rip), %rbx      # 0x15450
leaq 0x12b36(%rip), %rsi     # 0x21df9
movq %rbx, %rdi
callq 0x1150
leaq 0x1b79(%rip), %rsi      # 0x10e4b
leaq 0x120(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
leaq 0x2b8(%rsp), %rsi
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0xf311
leaq 0x120(%rsp), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0xf769
cmpb $0x0, 0x5e7b(%rip)      # 0x15193
je 0xf390
movdqu 0x1b63(%rip), %xmm0     # 0x10e85
movdqa %xmm0, 0x61f6(%rip)     # 0x15520
movl $0x5f6c61, 0x61fb(%rip) # imm = 0x5F6C61
leaq 0x61e5(%rip), %rbx      # 0x15520
leaq 0x12ab7(%rip), %rsi     # 0x21df9
movq %rbx, %rdi
callq 0x1150
leaq 0x1afa(%rip), %rsi      # 0x10e4b
leaq 0x120(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
leaq 0x2b8(%rsp), %rsi
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0xf390
leaq 0x120(%rsp), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0xf773
cmpb $0x0, 0x5df9(%rip)      # 0x15190
jne 0xf472
leaq 0x12a4c(%rip), %rbx     # 0x21df0
movq %rbx, %rdi
callq 0x1060
movl $0x676f6c2e, (%rax,%rbx) # imm = 0x676F6C2E
movb $0x0, 0x4(%rax,%rbx)
testb %r13b, %r13b
je 0xf3c6
movq 0x12a1c(%rip), %rdi     # 0x21de0
jmp 0xf3e3
leaq 0x12a23(%rip), %rdi     # 0x21df0
leaq 0x1ac9(%rip), %rsi      # 0x10e9d
callq 0x1120
movq %rax, %rdi
movq %rax, 0x129fd(%rip)     # 0x21de0
testq %rdi, %rdi
je 0xf836
movl 0x129e6(%rip), %eax     # 0x21dd8
leal 0x14(,%rax,2), %edx
leaq 0x1a9f(%rip), %rsi      # 0x10e9f
xorl %eax, %eax
callq 0x10b0
movq 0x129d2(%rip), %rdi     # 0x21de0
movl 0x129c0(%rip), %edx     # 0x21dd4
leaq 0x1aa0(%rip), %rsi      # 0x10ebb
xorl %eax, %eax
callq 0x10b0
movq 0x129b7(%rip), %rdi     # 0x21de0
movl 0x901d(%rip), %edx      # 0x1844c
leaq 0x1aa1(%rip), %rsi      # 0x10ed7
xorl %eax, %eax
callq 0x10b0
cmpl $0x3, 0x9008(%rip)      # 0x1844c
jne 0xf461
movq 0x12993(%rip), %rdi     # 0x21de0
movl 0xf4b5(%rip), %edx      # 0x1e908
leaq 0x1a8d(%rip), %rsi      # 0x10ee7
xorl %eax, %eax
callq 0x10b0
testb %r13b, %r13b
jne 0xf472
movq 0x12973(%rip), %rdi     # 0x21de0
callq 0x1050
callq 0x6c93
movl %ebp, %edi
callq 0x6a22
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %r14
cmpb $0x0, 0x5cfb(%rip)      # 0x15190
je 0xf5c7
cmpb $0x0, 0x1143a(%rip)     # 0x208dc
je 0xf4d7
movl 0x1292e(%rip), %edi     # 0x21dd8
movl 0x11428(%rip), %esi     # 0x208d8
callq 0xcbff
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %rbx
cmpb $0x0, 0x5cc4(%rip)      # 0x15190
je 0xf5e6
movq %rbx, %r14
jmp 0xf4d7
cmpb $0x0, 0x10f53(%rip)     # 0x20431
je 0xf50e
movl 0x128f2(%rip), %edi     # 0x21dd8
movl 0x113ec(%rip), %esi     # 0x208d8
callq 0xd6f1
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %rbx
cmpb $0x0, 0x5c88(%rip)      # 0x15190
je 0xf692
cmpb $0x0, 0x10f1b(%rip)     # 0x20430
je 0xf545
movl 0x128bb(%rip), %edi     # 0x21dd8
movl 0x113b5(%rip), %esi     # 0x208d8
callq 0xdf66
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %rbx
cmpb $0x0, 0x5c51(%rip)      # 0x15190
je 0xf740
cmpl $0x3, 0x8f00(%rip)      # 0x1844c
jne 0xf5aa
movslq 0x12883(%rip), %rax     # 0x21dd8
addq %rax, %rax
leal 0x14(%rax), %ecx
cmpl 0x12873(%rip), %ecx     # 0x21dd4
jg 0xf5aa
leaq 0x14(%rax), %r14
shlq $0x5, %rax
leaq 0x98ce(%rip), %rcx      # 0x18e40
leaq (%rax,%rcx), %r15
addq $0x280, %r15            # imm = 0x280
leaq 0xf38c(%rip), %r12      # 0x1e910
movq (%r12,%r14,8), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x3dbc
leaq 0x1(%r14), %rax
movslq 0x12836(%rip), %rcx     # 0x21dd4
addq $0x20, %r15
cmpq %rcx, %r14
movq %rax, %r14
jl 0xf584
cmpb $0x0, 0x5bdf(%rip)      # 0x15190
je 0xf5d8
xorl %eax, %eax
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %r13b, %esi
movq %r14, %rdi
callq 0x2492
jmp 0xf49b
movzbl %r13b, %esi
movq %rbx, %rdi
callq 0x25e4
jmp 0xf5b3
movq 0x5a0b(%rip), %rax      # 0x14ff8
movq (%rax), %r15
movq %rbx, %rax
subq %r14, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x2, %edi
callq 0x1130
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x1907(%rip), %rsi      # 0x10f2b
movq %r15, %rdi
movb $0x1, %al
callq 0x10b0
testb %r13b, %r13b
jne 0xf4d2
leaq 0x127b2(%rip), %rdi     # 0x21df0
leaq 0x18e4(%rip), %rsi      # 0x10f29
callq 0x1120
movq %rax, %r14
movq %rax, 0x1278c(%rip)     # 0x21de0
movl $0x2, %edi
callq 0x1130
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x18b4(%rip), %rsi      # 0x10f2b
movq %r14, %rdi
movb $0x1, %al
callq 0x10b0
movq 0x12758(%rip), %rdi     # 0x21de0
callq 0x1050
jmp 0xf4d2
movq 0x595f(%rip), %rax      # 0x14ff8
movq (%rax), %r15
movq %rbx, %rax
subq %r14, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x2, %edi
callq 0x1130
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x1893(%rip), %rsi      # 0x10f66
movq %r15, %rdi
movb $0x1, %al
callq 0x10b0
testb %r13b, %r13b
jne 0xf738
leaq 0x12707(%rip), %rdi     # 0x21df0
leaq 0x1839(%rip), %rsi      # 0x10f29
callq 0x1120
movq %rax, %r14
movq %rax, 0x126e1(%rip)     # 0x21de0
movl $0x2, %edi
callq 0x1130
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x1844(%rip), %rsi      # 0x10f66
movq %r14, %rdi
movb $0x1, %al
callq 0x10b0
movq 0x126ad(%rip), %rdi     # 0x21de0
callq 0x1050
movq %rbx, %r14
jmp 0xf50e
movzbl %r13b, %edx
leaq 0x48(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x2530
movq (%r15), %rbx
jmp 0xf545
callq 0x242c
jmp 0xf29b
callq 0x244e
jmp 0xf311
callq 0x2470
jmp 0xf390
callq 0x2254
movq %rbx, %rdi
callq 0x219f
movq %rbx, %rdi
callq 0x21c3
movq %rbx, %rdi
callq 0x2157
callq 0x217b
movq %rbx, %rdi
callq 0x22c2
movq %rbx, %rdi
callq 0x229e
movq %rbx, %rdi
callq 0x23be
leaq 0x50(%rsp), %rdi
callq 0x2377
leaq 0x1416(%rip), %rsi      # 0x10bde
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10b0
movl $0x6a, %edi
callq 0x1170
movq %rbx, %rdi
callq 0x21e7
movl $0x5d, %edi
callq 0x1170
callq 0x2a8e
callq 0x2a69
movl %ebp, %edi
callq 0x2a46
callq 0x23e2
leaq 0x50(%rsp), %rdi
callq 0x2353
leaq 0x50(%rsp), %rdi
callq 0x22e6
leaq 0x50(%rsp), %rdi
callq 0x232f
callq 0x230a
callq 0x2279
callq 0x2407
callq 0x220b
callq 0x2a1e
movq %rbx, %rdi
callq 0x2230
callq 0x239b