// File: /workspace/github_c_makefile_star2_O1/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 $0x358, %rsp            # imm = 0x358
movq %rsi, %r14
movl %edi, %ebx
leaq 0x12514(%rip), %rdi     # 0x20b38
movl $0x1220, %edx           # imm = 0x1220
xorl %esi, %esi
callq 0x1080
leaq 0xf0b1(%rip), %rdi      # 0x1d6e8
movl $0x1220, %edx           # imm = 0x1220
xorl %esi, %esi
callq 0x1080
movb $0x1, %al
movb %al, 0x12291(%rip)      # 0x208dc
movb %al, 0x11ddf(%rip)      # 0x20430
movb %al, 0x11dda(%rip)      # 0x20431
movb $0x0, 0x13702(%rip)     # 0x21d60
movl %ebx, 0x10(%rsp)
cmpl $0x1, %ebx
jle 0xf7dd
movq 0x8(%r14), %rdi
callq 0x1140
movl %eax, 0x1375a(%rip)     # 0x21dd4
cmpl $0x14, %eax
jl 0xf7e7
movl %eax, %ecx
andl $0x1, %ecx
jne 0xf7e7
leal -0x14(%rax), %ecx
movl %ecx, %edi
shrl %edi
movl %edi, 0x1223d(%rip)     # 0x208d8
movl %edi, 0x13737(%rip)     # 0x21dd8
cmpl $0xfffe, %eax           # imm = 0xFFFE
jge 0xf7ec
cmpl $0x119, %ecx            # imm = 0x119
jae 0xf7f1
movl %edi, 0x14(%rsp)
xorl %ebp, %ebp
movl %ebp, 0x10244(%rip)     # 0x1e908
movl %ebp, 0x9d82(%rip)      # 0x1844c
movl $0x0, %eax
cmpl $0x2, 0x10(%rsp)
je 0xeb3a
movl $0x2, %r12d
xorl %r13d, %r13d
movl $0x1, 0x18(%rsp)
xorl %ebp, %ebp
movslq %r12d, %r15
movq (%r14,%r15,8), %rbx
movzbl (%rbx), %eax
addl $-0x63, %eax
cmpl $0x10, %eax
ja 0xf78f
leaq 0x1a82(%rip), %rcx      # 0x1018c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
leaq 0x2540(%rip), %rsi      # 0x10c5d
callq 0x10a0
testl %eax, %eax
je 0xeab5
movq %rbx, %rdi
leaq 0x252e(%rip), %rsi      # 0x10c62
callq 0x10a0
testl %eax, %eax
jne 0xf7d5
incl %r12d
movq 0x8(%r14,%r15,8), %rdi
callq 0x1140
cmpl $0x3, %eax
je 0xeaef
cmpl $0x2, %eax
je 0xead3
cmpl $0x1, %eax
jne 0xf805
movb %r13b, 0x11cc0(%rip)    # 0x20430
movb %r13b, 0x11cba(%rip)    # 0x20431
movb $0x1, 0x1215e(%rip)     # 0x208dc
movl $0x1, %ebp
jmp 0xeb24
movq %rbx, %rdi
leaq 0x24fb(%rip), %rsi      # 0x10c8d
callq 0x10a0
testl %eax, %eax
jne 0xf772
movq 0x8(%r14,%r15,8), %rdi
callq 0x1140
movl %eax, %ebx
movl %eax, 0x69eb(%rip)      # 0x1519c
movq 0x10(%r14,%r15,8), %rdi
callq 0x1140
movl %eax, 0x69d7(%rip)      # 0x15198
testl %eax, %eax
jle 0xf77a
testl %ebx, %ebx
js 0xf77a
cmpl %eax, %ebx
jge 0xf77a
addl $0x2, %r12d
jmp 0xeb24
movq %rbx, %rdi
leaq 0x248b(%rip), %rsi      # 0x10c77
callq 0x10a0
testl %eax, %eax
jne 0xf76a
movq 0x67d8(%rip), %r15      # 0x14fd8
movq (%r15), %rbx
callq 0x1040
movq %rbx, %rdi
leaq 0x1f65(%rip), %rsi      # 0x10777
movl %eax, %edx
xorl %eax, %eax
callq 0x10b0
movq (%r15), %rdi
callq 0x10f0
jmp 0xeb24
movq %rbx, %rdi
leaq 0x25da(%rip), %rsi      # 0x10e0c
callq 0x10a0
testl %eax, %eax
jne 0xf77f
movb $0x1, 0x694b(%rip)      # 0x15191
jmp 0xeb24
movq %rbx, %rdi
leaq 0x2396(%rip), %rsi      # 0x10beb
callq 0x10a0
testl %eax, %eax
je 0xea6f
movq %rbx, %rdi
leaq 0x23aa(%rip), %rsi      # 0x10c16
callq 0x10a0
testl %eax, %eax
je 0xeaca
movq %rbx, %rdi
leaq 0x239a(%rip), %rsi      # 0x10c1d
callq 0x10a0
testl %eax, %eax
je 0xeb0b
movq %rbx, %rdi
leaq 0x238b(%rip), %rsi      # 0x10c25
callq 0x10a0
testl %eax, %eax
je 0xeb14
movq %rbx, %rdi
leaq 0x2380(%rip), %rsi      # 0x10c31
callq 0x10a0
testl %eax, %eax
je 0xeb1d
movq %rbx, %rdi
leaq 0x2371(%rip), %rsi      # 0x10c39
callq 0x10a0
testl %eax, %eax
jne 0xf814
movb $0x1, 0x68c4(%rip)      # 0x151a0
incl %r12d
cmpl 0x10(%rsp), %r12d
jge 0xf80a
movq %r14, 0x28(%rsp)
movl %ebp, 0x8(%rsp)
movl 0x6957(%rip), %eax      # 0x15250
movq %rax, 0x20(%rsp)
movslq %r12d, %rbx
movl $0x1c, %ebp
xorl %r14d, %r14d
leaq 0x6840(%rip), %r15      # 0x15150
movq %rbx, 0x30(%rsp)
xorl %eax, %eax
movzbl (%r15,%rax), %ecx
cmpb $0x20, %cl
cmovel %r13d, %ecx
movb %cl, 0x1c(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0xe917
movq 0x28(%rsp), %rax
movq (%rax,%rbx,8), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x10a0
testl %eax, %eax
jne 0xe9b0
movq 0x20(%rsp), %rsi
testl %esi, %esi
leaq 0x68db(%rip), %rdx      # 0x15230
jle 0xe969
movl %esi, %eax
xorl %ecx, %ecx
cmpb %bpl, (%rcx,%rdx)
je 0xe9ad
incq %rcx
cmpq %rcx, %rax
jne 0xe95b
leal 0x1(%rsi), %ebx
movl %ebx, 0x68de(%rip)      # 0x15250
movslq %esi, %rax
movb %bpl, (%rax,%rdx)
leaq 0x133e0(%rip), %r14     # 0x21d60
movq %r14, %rdi
callq 0x1060
movw $0x5f, (%rax,%r14)
movq %r14, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x1150
movb $0x1, %r14b
movl %ebx, %eax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rbx
jmp 0xe9b0
movb $0x1, %r14b
cmpq $0x2, %rbp
jb 0xe9c6
decq %rbp
addq $-0x4, %r15
testb %r14b, %r14b
je 0xe915
testb %r14b, %r14b
movl 0x8(%rsp), %ebp
movq 0x28(%rsp), %r14
jne 0xeb24
jmp 0xf80a
movq %rbx, %rdi
leaq 0x229a(%rip), %rsi      # 0x10c81
callq 0x10a0
testl %eax, %eax
je 0xeaa0
movq %rbx, %rdi
leaq 0x2288(%rip), %rsi      # 0x10c86
callq 0x10a0
movq 0x65ee(%rip), %rcx      # 0x14ff8
movq (%rcx), %rdi
testl %eax, %eax
jne 0xf7ba
movq %rdi, 0x133c4(%rip)     # 0x21de0
movl $0x0, 0x18(%rsp)
jmp 0xeb24
movq %rbx, %rdi
leaq 0x21b1(%rip), %rsi      # 0x10be4
callq 0x10a0
testl %eax, %eax
jne 0xf787
movb $0x1, 0x674c(%rip)      # 0x15193
jmp 0xeb24
movq %rbx, %rdi
leaq 0x2225(%rip), %rsi      # 0x10c7b
callq 0x10a0
testl %eax, %eax
jne 0xf762
movb $0x1, 0x6726(%rip)      # 0x15190
jmp 0xeb24
movq 0x8(%r14,%r15,8), %rdi
callq 0x1140
cmpl $0x14, %eax
jl 0xf7fb
movl %eax, %ecx
andl $0x1, %ecx
jne 0xf7fb
incl %r12d
addl $-0x14, %eax
shrl %eax
movl %eax, 0x1333d(%rip)     # 0x21dd8
jmp 0xeb24
incl %r12d
movq 0x8(%r14,%r15,8), %rdi
callq 0x1140
movl %eax, 0xfe55(%rip)      # 0x1e908
jmp 0xeb24
incl %r12d
movq 0x8(%r14,%r15,8), %rdi
callq 0x1140
movl %eax, 0x9984(%rip)      # 0x1844c
jmp 0xeb24
movb $0x1, 0x66c1(%rip)      # 0x15192
jmp 0xeb24
movb $0x1, 0x11957(%rip)     # 0x20431
movb %r13b, 0x11dfb(%rip)    # 0x208dc
movb %r13b, 0x11948(%rip)    # 0x20430
movl $0x2, %ebp
jmp 0xeb24
movb %r13b, 0x11de6(%rip)    # 0x208dc
movb %r13b, 0x11934(%rip)    # 0x20431
movb $0x1, 0x1192c(%rip)     # 0x20430
movl $0x3, %ebp
jmp 0xeb24
movb $0x1, 0x6682(%rip)      # 0x15194
jmp 0xeb24
movb $0x1, 0x667a(%rip)      # 0x15195
jmp 0xeb24
movb $0x1, 0x667c(%rip)      # 0x151a0
incl %r12d
cmpl 0x10(%rsp), %r12d
jl 0xe6ed
cmpl $0x0, 0x18(%rsp)
sete %al
movl %ebp, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movl 0x9904(%rip), %edi      # 0x1844c
cmpq $0x8, %rdi
ja 0xf81c
leaq 0x1677(%rip), %rax      # 0x101d0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movslq 0x1326f(%rip), %rbx     # 0x21dd8
addq %rbx, %rbx
leal 0x14(%rbx), %eax
cmpl 0x1325f(%rip), %eax     # 0x21dd4
jg 0xf093
addq $0x14, %rbx
leaq 0x2139(%rip), %rbp      # 0x10cbf
leaq 0x2120(%rip), %r13      # 0x10cad
leaq 0x60(%rsp), %r14
leaq 0x8687(%rip), %r15      # 0x17220
leaq 0x200(%rsp), %r12
cmpb $0x0, 0x65e9(%rip)      # 0x15191
movq %r13, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x8(%rsp), %edx
testl %edx, %edx
je 0xebdf
movq %r12, %rdi
leaq 0x2100(%rip), %rsi      # 0x10ccd
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x65b3(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xec0b
movl 0x65ad(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x20d9(%rip), %rsi      # 0x10cd2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x663e(%rip)      # 0x15250
jle 0xec23
movq %r14, %rdi
leaq 0x13142(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x6568(%rip)      # 0x15192
je 0xec38
movq 0x63a5(%rip), %rax      # 0x14fd8
movq (%rax), %rax
jmp 0xec47
movq %r14, %rdi
leaq 0x2099(%rip), %rsi      # 0x10cdb
callq 0x1120
leaq (,%rbx,8), %rcx
movq %rax, (%rcx,%r15)
cmpb $0x0, 0x6538(%rip)      # 0x15192
jne 0xec6a
leaq 0x98bd(%rip), %rax      # 0x18520
movl $0x1, (%rax,%rbx,4)
cmpq $0x0, (%r15,%rbx,8)
je 0xf758
addq $0x2, %rbx
movslq 0x13154(%rip), %rax     # 0x21dd4
cmpq %rax, %rbx
jle 0xeba1
jmp 0xf093
movb $0x1, 0x6500(%rip)      # 0x15195
jmp 0xf093
movslq 0x13137(%rip), %rbx     # 0x21dd8
addq %rbx, %rbx
leal 0x14(%rbx), %eax
cmpl 0x13127(%rip), %eax     # 0x21dd4
jg 0xedc1
addq $0x14, %rbx
leaq 0x204c(%rip), %rbp      # 0x10d0a
leaq 0x2031(%rip), %r13      # 0x10cf6
leaq 0x60(%rsp), %r14
leaq 0x854f(%rip), %r15      # 0x17220
leaq 0x200(%rsp), %r12
cmpb $0x0, 0x64b1(%rip)      # 0x15191
movq %r13, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x8(%rsp), %edx
testl %edx, %edx
je 0xed17
movq %r12, %rdi
leaq 0x1fc8(%rip), %rsi      # 0x10ccd
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x647b(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xed43
movl 0x6475(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x1fa1(%rip), %rsi      # 0x10cd2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x6506(%rip)      # 0x15250
jle 0xed5b
movq %r14, %rdi
leaq 0x1300a(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x6430(%rip)      # 0x15192
je 0xed70
movq 0x626d(%rip), %rax      # 0x14fd8
movq (%rax), %rax
jmp 0xed7f
movq %r14, %rdi
leaq 0x1f61(%rip), %rsi      # 0x10cdb
callq 0x1120
leaq (,%rbx,8), %rcx
movq %rax, (%rcx,%r15)
cmpb $0x0, 0x6400(%rip)      # 0x15192
jne 0xeda2
leaq 0x9785(%rip), %rax      # 0x18520
movl $0x1, (%rax,%rbx,4)
cmpq $0x0, (%r15,%rbx,8)
je 0xf797
addq $0x2, %rbx
movslq 0x1301c(%rip), %rax     # 0x21dd4
cmpq %rax, %rbx
jle 0xecd9
movb $0x1, 0x63cd(%rip)      # 0x15195
movb $-0x1, 0xa065(%rip)     # 0x18e34
jmp 0xf093
movb $0x1, 0x63ba(%rip)      # 0x15195
cmpl $0x0, 0xfb26(%rip)      # 0x1e908
jne 0xedee
movl $0x7d0, 0xfb1a(%rip)    # imm = 0x7D0
movslq 0x12fe3(%rip), %rax     # 0x21dd8
addq %rax, %rax
leal 0x14(%rax), %ecx
cmpl 0x12fd3(%rip), %ecx     # 0x21dd4
jg 0xf093
leaq 0x14(%rax), %rbx
shlq $0x5, %rax
leaq 0xa02a(%rip), %rcx      # 0x18e40
leaq (%rax,%rcx), %rbp
addq $0x280, %rbp            # imm = 0x280
leaq 0x60(%rsp), %r14
leaq 0x83f3(%rip), %r15      # 0x17220
leaq 0x200(%rsp), %r12
cmpb $0x0, 0x6355(%rip)      # 0x15191
movb $0x0, (%rbp)
leaq 0x1eaf(%rip), %rsi      # 0x10cf6
leaq 0x1ebc(%rip), %rax      # 0x10d0a
cmoveq %rax, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x8(%rsp), %edx
testl %edx, %edx
je 0xee82
movq %r12, %rdi
leaq 0x1e5d(%rip), %rsi      # 0x10ccd
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x6310(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xeeae
movl 0x630a(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x1e36(%rip), %rsi      # 0x10cd2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x639b(%rip)      # 0x15250
jle 0xeec6
movq %r14, %rdi
leaq 0x12e9f(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x62c5(%rip)      # 0x15192
je 0xeedb
movq 0x6102(%rip), %rax      # 0x14fd8
movq (%rax), %rax
jmp 0xeeea
movq %r14, %rdi
leaq 0x1df6(%rip), %rsi      # 0x10cdb
callq 0x1120
leaq (,%rbx,8), %rcx
movq %rax, (%rcx,%r15)
cmpb $0x0, 0x6295(%rip)      # 0x15192
jne 0xef0d
leaq 0x961a(%rip), %rax      # 0x18520
movl $0x1, (%rax,%rbx,4)
cmpq $0x0, (%r15,%rbx,8)
je 0xf7ab
movl $0x8, %edi
callq 0x10e0
movq %rax, %r13
leaq 0xf9e4(%rip), %rax      # 0x1e910
movq %r13, (%rax,%rbx,8)
testq %r13, %r13
je 0xf7b5
movl $0xc, %edi
callq 0x10e0
movq %rax, (%r13)
movb $-0x1, (%rax)
addq $0x2, %rbx
movslq 0x12e7f(%rip), %rax     # 0x21dd4
addq $0x40, %rbp
cmpq %rax, %rbx
jle 0xee35
jmp 0xf093
movb $0x1, 0x6227(%rip)      # 0x15195
movslq 0x12e63(%rip), %rbx     # 0x21dd8
addq %rbx, %rbx
leal 0x14(%rbx), %eax
cmpl 0x12e53(%rip), %eax     # 0x21dd4
jg 0xf093
addq $0x14, %rbx
leaq 0x1d2d(%rip), %rbp      # 0x10cbf
leaq 0x1d14(%rip), %r13      # 0x10cad
leaq 0x60(%rsp), %r14
leaq 0x827b(%rip), %r15      # 0x17220
leaq 0x200(%rsp), %r12
cmpb $0x0, 0x61dd(%rip)      # 0x15191
movq %r13, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1160
movl 0x8(%rsp), %edx
testl %edx, %edx
je 0xefeb
movq %r12, %rdi
leaq 0x1cf4(%rip), %rsi      # 0x10ccd
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
movl 0x61a7(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xf017
movl 0x61a1(%rip), %edx      # 0x1519c
movq %r12, %rdi
leaq 0x1ccd(%rip), %rsi      # 0x10cd2
xorl %eax, %eax
callq 0x1160
movq %r14, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $0x0, 0x6232(%rip)      # 0x15250
jle 0xf02f
movq %r14, %rdi
leaq 0x12d36(%rip), %rsi     # 0x21d60
callq 0x1150
cmpb $0x0, 0x615c(%rip)      # 0x15192
je 0xf044
movq 0x5f99(%rip), %rax      # 0x14fd8
movq (%rax), %rax
jmp 0xf053
movq %r14, %rdi
leaq 0x1c8d(%rip), %rsi      # 0x10cdb
callq 0x1120
leaq (,%rbx,8), %rcx
movq %rax, (%rcx,%r15)
testq %rax, %rax
je 0xf7a1
cmpb $0x0, 0x6123(%rip)      # 0x15192
jne 0xf07f
leaq 0x94a8(%rip), %rax      # 0x18520
movl $0x1, (%rax,%rbx,4)
addq $0x2, %rbx
movslq 0x12d4a(%rip), %rax     # 0x21dd4
cmpq %rax, %rbx
jle 0xefad
cmpb $0x0, 0x60f9(%rip)      # 0x15193
je 0xf0a9
cmpb $0x0, 0x60f2(%rip)      # 0x15195
je 0xf7f6
movb 0x60e5(%rip), %al       # 0x15194
testb %al, %al
movl 0x8(%rsp), %r14d
je 0xf100
movl 0x12d1a(%rip), %ecx     # 0x21dd8
cmpl 0x11814(%rip), %ecx     # 0x208d8
jne 0xf800
testb %al, %al
je 0xf100
movl 0x11804(%rip), %eax     # 0x208d8
cmpl $-0xa, %eax
jl 0xf100
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 0x64f7(%rip), %rdi      # 0x155f0
xorl %esi, %esi
callq 0x1080
cmpb $0x0, 0x608a(%rip)      # 0x15191
movl 0x12ccb(%rip), %eax     # 0x21dd8
movl 0x117c5(%rip), %ecx     # 0x208d8
movl 0x12cbb(%rip), %edx     # 0x21dd4
je 0xf138
cmpl %ecx, %eax
movl 0x14(%rsp), %ebp
movl 0x10(%rsp), %r13d
jne 0xf15c
leaq 0x12cc1(%rip), %rdi     # 0x21df0
leaq 0x1cb7(%rip), %rsi      # 0x10ded
jmp 0xf153
cmpl %ecx, %eax
movl 0x14(%rsp), %ebp
movl 0x10(%rsp), %r13d
jne 0xf173
leaq 0x12ca4(%rip), %rdi     # 0x21df0
leaq 0x1cbd(%rip), %rsi      # 0x10e10
xorl %eax, %eax
callq 0x1160
jmp 0xf18f
leal 0x14(,%rax,2), %ecx
leaq 0x12c86(%rip), %rdi     # 0x21df0
leaq 0x1c8c(%rip), %rsi      # 0x10dfd
jmp 0xf188
leal 0x14(,%rax,2), %ecx
leaq 0x12c6f(%rip), %rdi     # 0x21df0
leaq 0x1c94(%rip), %rsi      # 0x10e1c
xorl %eax, %eax
callq 0x1160
testl %r14d, %r14d
je 0xf1bf
leaq 0x1b32(%rip), %rsi      # 0x10ccd
leaq 0x200(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1160
leaq 0x12c39(%rip), %rdi     # 0x21df0
movq %rbx, %rsi
callq 0x1150
movl 0x5fd3(%rip), %ecx      # 0x15198
testl %ecx, %ecx
je 0xf1f7
movl 0x5fcd(%rip), %edx      # 0x1519c
leaq 0x1afc(%rip), %rsi      # 0x10cd2
leaq 0x200(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
leaq 0x12c01(%rip), %rdi     # 0x21df0
movq %rbx, %rsi
callq 0x1150
cmpb $0x0, 0x5f97(%rip)      # 0x15195
je 0xf2f1
movabsq $0x61726970735f6f4e, %rax # imm = 0x61726970735F6F4E
movq %rax, 0x923b(%rip)      # 0x18450
movl $0x5f6c61, 0x9238(%rip) # imm = 0x5F6C61
leaq 0x922a(%rip), %rbx      # 0x18450
leaq 0x12bcc(%rip), %rsi     # 0x21df9
movq %rbx, %rdi
callq 0x1150
leaq 0x1bfa(%rip), %rsi      # 0x10e36
leaq 0x130(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
leaq 0x2c8(%rsp), %rsi
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0xf27b
leaq 0x130(%rsp), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0xf73a
movupd 0x1bd9(%rip), %xmm0     # 0x10e5c
movapd %xmm0, 0x61c5(%rip)     # 0x15450
movl $0x5f6c61, 0x61cb(%rip) # imm = 0x5F6C61
leaq 0x61b4(%rip), %rbx      # 0x15450
leaq 0x12b56(%rip), %rsi     # 0x21df9
movq %rbx, %rdi
callq 0x1150
leaq 0x1b84(%rip), %rsi      # 0x10e36
leaq 0x130(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
leaq 0x2c8(%rsp), %rsi
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0xf2f1
leaq 0x130(%rsp), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0xf744
cmpb $0x0, 0x5e9b(%rip)      # 0x15193
je 0xf370
movupd 0x1b6e(%rip), %xmm0     # 0x10e70
movapd %xmm0, 0x6216(%rip)     # 0x15520
movl $0x5f6c61, 0x621b(%rip) # imm = 0x5F6C61
leaq 0x6205(%rip), %rbx      # 0x15520
leaq 0x12ad7(%rip), %rsi     # 0x21df9
movq %rbx, %rdi
callq 0x1150
leaq 0x1b05(%rip), %rsi      # 0x10e36
leaq 0x130(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
leaq 0x2c8(%rsp), %rsi
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0xf370
leaq 0x130(%rsp), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0xf74e
cmpb $0x0, 0x5e19(%rip)      # 0x15190
jne 0xf44d
leaq 0x12a6c(%rip), %rbx     # 0x21df0
movq %rbx, %rdi
callq 0x1060
movl $0x676f6c2e, (%rax,%rbx) # imm = 0x676F6C2E
movb $0x0, 0x4(%rax,%rbx)
testb %r13b, %r13b
jne 0xf3b7
leaq 0x12a4c(%rip), %rdi     # 0x21df0
leaq 0x1add(%rip), %rsi      # 0x10e88
callq 0x1120
movq %rax, 0x12a29(%rip)     # 0x21de0
movq 0x12a22(%rip), %rdi     # 0x21de0
testq %rdi, %rdi
je 0xf80f
movl 0x12a0b(%rip), %eax     # 0x21dd8
leal 0x14(,%rax,2), %edx
leaq 0x1aaf(%rip), %rsi      # 0x10e8a
xorl %eax, %eax
callq 0x10b0
movq 0x129f7(%rip), %rdi     # 0x21de0
movl 0x129e5(%rip), %edx     # 0x21dd4
leaq 0x1ab0(%rip), %rsi      # 0x10ea6
xorl %eax, %eax
callq 0x10b0
movq 0x129dc(%rip), %rdi     # 0x21de0
movl 0x9042(%rip), %edx      # 0x1844c
leaq 0x1ab1(%rip), %rsi      # 0x10ec2
xorl %eax, %eax
callq 0x10b0
cmpl $0x3, 0x902d(%rip)      # 0x1844c
jne 0xf43c
movq 0x129b8(%rip), %rdi     # 0x21de0
movl 0xf4da(%rip), %edx      # 0x1e908
leaq 0x1a9d(%rip), %rsi      # 0x10ed2
xorl %eax, %eax
callq 0x10b0
testb %r13b, %r13b
jne 0xf44d
movq 0x12998(%rip), %rdi     # 0x21de0
callq 0x1050
callq 0x6b27
movl %ebp, %edi
callq 0x68be
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %r14
cmpb $0x0, 0x5d20(%rip)      # 0x15190
je 0xf5a2
cmpb $0x0, 0x1145f(%rip)     # 0x208dc
je 0xf4b2
movl 0x12953(%rip), %edi     # 0x21dd8
movl 0x1144d(%rip), %esi     # 0x208d8
callq 0xcbda
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %rbx
cmpb $0x0, 0x5ce9(%rip)      # 0x15190
je 0xf5c1
movq %rbx, %r14
jmp 0xf4b2
cmpb $0x0, 0x10f78(%rip)     # 0x20431
je 0xf4e9
movl 0x12917(%rip), %edi     # 0x21dd8
movl 0x11411(%rip), %esi     # 0x208d8
callq 0xd6bc
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %rbx
cmpb $0x0, 0x5cad(%rip)      # 0x15190
je 0xf66d
cmpb $0x0, 0x10f40(%rip)     # 0x20430
je 0xf520
movl 0x128e0(%rip), %edi     # 0x21dd8
movl 0x113da(%rip), %esi     # 0x208d8
callq 0xdf46
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %rbx
cmpb $0x0, 0x5c76(%rip)      # 0x15190
je 0xf71b
cmpl $0x3, 0x8f25(%rip)      # 0x1844c
jne 0xf585
movslq 0x128a8(%rip), %rax     # 0x21dd8
addq %rax, %rax
leal 0x14(%rax), %ecx
cmpl 0x12898(%rip), %ecx     # 0x21dd4
jg 0xf585
leaq 0x14(%rax), %r14
shlq $0x5, %rax
leaq 0x98f3(%rip), %rcx      # 0x18e40
leaq (%rax,%rcx), %r15
addq $0x280, %r15            # imm = 0x280
leaq 0xf3b1(%rip), %r12      # 0x1e910
movq (%r12,%r14,8), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x3d7e
leaq 0x1(%r14), %rax
movslq 0x1285b(%rip), %rcx     # 0x21dd4
addq $0x20, %r15
cmpq %rcx, %r14
movq %rax, %r14
jl 0xf55f
cmpb $0x0, 0x5c04(%rip)      # 0x15190
je 0xf5b3
xorl %eax, %eax
addq $0x358, %rsp            # imm = 0x358
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %r13b, %esi
movq %r14, %rdi
callq 0x24b9
jmp 0xf476
movzbl %r13b, %esi
movq %rbx, %rdi
callq 0x260b
jmp 0xf58e
movq 0x5a30(%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 0x1917(%rip), %rsi      # 0x10f16
movq %r15, %rdi
movb $0x1, %al
callq 0x10b0
testb %r13b, %r13b
jne 0xf4ad
leaq 0x127d7(%rip), %rdi     # 0x21df0
leaq 0x18f4(%rip), %rsi      # 0x10f14
callq 0x1120
movq %rax, %r14
movq %rax, 0x127b1(%rip)     # 0x21de0
movl $0x2, %edi
callq 0x1130
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x18c4(%rip), %rsi      # 0x10f16
movq %r14, %rdi
movb $0x1, %al
callq 0x10b0
movq 0x1277d(%rip), %rdi     # 0x21de0
callq 0x1050
jmp 0xf4ad
movq 0x5984(%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 0x18a3(%rip), %rsi      # 0x10f51
movq %r15, %rdi
movb $0x1, %al
callq 0x10b0
testb %r13b, %r13b
jne 0xf713
leaq 0x1272c(%rip), %rdi     # 0x21df0
leaq 0x1849(%rip), %rsi      # 0x10f14
callq 0x1120
movq %rax, %r14
movq %rax, 0x12706(%rip)     # 0x21de0
movl $0x2, %edi
callq 0x1130
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x1854(%rip), %rsi      # 0x10f51
movq %r14, %rdi
movb $0x1, %al
callq 0x10b0
movq 0x126d2(%rip), %rdi     # 0x21de0
callq 0x1050
movq %rbx, %r14
jmp 0xf4e9
movzbl %r13b, %edx
leaq 0x58(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x2557
movq (%r15), %rbx
jmp 0xf520
callq 0x2453
jmp 0xf27b
callq 0x2475
jmp 0xf2f1
callq 0x2497
jmp 0xf370
leaq 0x60(%rsp), %rdi
callq 0x23e5
movq %rbx, %rdi
callq 0x21e9
movq %rbx, %rdi
callq 0x220d
movq %rbx, %rdi
callq 0x21a1
callq 0x21c5
movq %rbx, %rdi
callq 0x230c
movq %rbx, %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2330
leaq 0x60(%rsp), %rdi
callq 0x23c1
leaq 0x60(%rsp), %rdi
callq 0x2354
leaq 0x60(%rsp), %rdi
callq 0x239d
callq 0x2378
leaq 0x1408(%rip), %rsi      # 0x10bc9
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10b0
movl $0x6a, %edi
callq 0x1170
movq %rbx, %rdi
callq 0x2231
movl $0x5d, %edi
callq 0x1170
callq 0x2abf
callq 0x2a9a
callq 0x2a77
callq 0x2409
callq 0x22c3
callq 0x242e
callq 0x2255
callq 0x229e
callq 0x2a2c
movq %rbx, %rdi
callq 0x227a
callq 0x2a54