// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: baue_auf
void baue_auf(PLANMAP map, SEQUENZ sq, int sechsecke)
{

SEQUENZ localseq;
int j, i, laenge;
KANTE *naechste, *nextmark, *run;
int anzahl, naechste_stelle, sql;


if (IPR && (!is_ipr))  return;

sql=sq.laenge;

if (sql >=2)
{
for (i=0; i<sql && ((i==0) || !((sq.k_marks)[i])); i++) 
                                            /* Schleife ueber alle moeglichen Startpunkte */
  {
    laenge=sq.sequenz[i]; 
    if (i==sql-1) naechste_stelle=0; else naechste_stelle=i+1;
    if (laenge==0)
    {
    /* da nie eine 0 am anfang einer kanonischen Sequenz stehen kann, kann die erste einer
       doppel-0 nie am ende stehen, also: */
      if ( (i<sql-1) && (sq.sequenz[i+1]==0) )
	{
	  if (sechsecke >= 1)
	    { 
	      naechste=sq.kanten[i];
	      { add_polygon(6,map,naechste,&naechste); nextmark=naechste; }
	      belege_sequenz(nextmark,&localseq); 
	      if (localseq.k_marks[0])
		{ schreibe_auf(map,localseq,sechsecke-1);
		  baue_auf(map, localseq, sechsecke-1); }
	      /* aufraeumen: */
	      (map[0][0].name) = (map[0][0].name) - 4;
	      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
	      run=run->next->invers->next; run->name=aussen; run->invers=nil;
	    }   /* ende if ...*/
	  naechste=sq.kanten[i];
	  { add_polygon(5,map,naechste,&naechste); nextmark=naechste; }
	  belege_sequenz(nextmark,&localseq); 
	  if (localseq.k_marks[0])
	    { schreibe_auf(map,localseq,sechsecke);
	      baue_auf(map, localseq, sechsecke); }
	  /* aufraeumen: */
	  is_ipr=1;
	  (map[0][0].name) = (map[0][0].name) - 3;
	  run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
	  run=run->next->invers->next; run->name=aussen; run->invers=nil;

	}

    if (sq.laenge==2) /* nur dann oder im vorigen Fall muss auch an 0er angelegt werden */
    {
    /* In diesem Teil wird die Sequenz nicht a priori berechnet, sondern erst im nachhinein --
       das kostet zwar Zeit, ist aber einfacher und braucht nicht so wahnsinnig viele
       Fallunterscheidungen */

    if (i != 1) { fprintf(stderr,"ERROR: i should be 1 !\n"); exit(26); }
    anzahl= 2 + sq.sequenz[0]; /* Bei laenge 0 muss der naechste mit aufgefuellt werden,
					       um keine Doppel-Innenkanten zu erhalten */

    /* erst nur 6-Ecke */
    if (sechsecke >= anzahl)
      { 
      naechste=sq.kanten[i];
      if (anzahl==1) { add_polygon(6,map,naechste,&naechste); nextmark=naechste; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<anzahl; j++)  add_polygon(6,map,naechste,&naechste); }
      belege_sequenz(nextmark,&localseq); 
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-anzahl);
	     baue_auf(map, localseq, sechsecke-anzahl); }
      /* aufraeumen: */
      (map[0][0].name) = (map[0][0].name) - 2*anzahl -2;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
      run=run->next->invers->next; run->name=aussen; run->invers=nil;
      for (j=2 ; j<anzahl; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if ...*/



    /* dann ein 5- und 6-Ecke */
    if (sechsecke >= anzahl-1)
      { 
      naechste=sq.kanten[i];
      if (anzahl==1) { add_polygon(5,map,naechste,&naechste); nextmark=naechste; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<anzahl-1; j++)  add_polygon(6,map,naechste,&naechste);  
               add_polygon(5,map,naechste,&naechste);  }
      belege_sequenz(nextmark,&localseq);
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-anzahl+1);
	     baue_auf(map, localseq, sechsecke-anzahl+1); }
      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*anzahl-1;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
      run=run->next->invers->next; run->name=aussen; run->invers=nil;
      for (j=2 ; j<anzahl; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if ... */

    /* dann eventuell zwei 5- und der Rest 6-Ecke um es zu 0-Sequenz zu machen */
    if (sechsecke >= anzahl-2)
      {
      naechste=sq.kanten[i];
      add_polygon(5,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
      for (j=1; j<anzahl-1; j++)  add_polygon(6,map,naechste,&naechste);  
      add_polygon(5,map,naechste,&naechste); 
      belege_sequenz(nextmark,&localseq);
      check_mark_und_schreibe(map,nextmark,localseq.sequenz[0],sechsecke-anzahl+2);

      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*anzahl;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
      run=run->next->invers->next; run->name=aussen; run->invers=nil;
      for (j=2; j<anzahl; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }

      }   /* ende if */
     } /* ende if sq.laenge==2 */
    } /* ende laenge==0 */


    else /* d.h. laenge !=0 */
    {

    /* ein sonderfall, wenn der naechste ein 0er ist (der erste aber nicht)--
       dann musss da noch ein 6-Eck mehr angefuegt werden: */

      if ((sq.sequenz[naechste_stelle]==0) && (sql>2))
	  { 
	    if (sechsecke >= laenge+1)
	    { 
	      naechste=sq.kanten[i];
              add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
	      /* insgesamt laenge+1: */
	      for (j=1; j<=laenge; j++)  add_polygon(6,map,naechste,&naechste);  
	      belege_sequenz(nextmark,&localseq); 
	      if (localseq.k_marks[0])
		{ schreibe_auf(map,localseq,sechsecke-laenge-1);
		  baue_auf(map, localseq, sechsecke-laenge-1); }
              /* aufraeumen: */
	      (map[0][0].name) = (map[0][0].name) - 2*laenge -4;
	      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
	      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
					 run->name=aussen; run->invers=nil; }
	      run=run->next->invers->next; run->name=aussen; run->invers=nil;

	    }   /* ende if ...*/
	    if (sechsecke >= laenge)
	    { 
	      naechste=sq.kanten[i];
              add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
	      /* insgesamt laenge+1: */
	      for (j=1; j<laenge; j++)  add_polygon(6,map,naechste,&naechste);  
	      add_polygon(5,map,naechste,&naechste);  
	      belege_sequenz(nextmark,&localseq); 
	      if (localseq.k_marks[0])
		{ schreibe_auf(map,localseq,sechsecke-laenge);
		  baue_auf(map, localseq, sechsecke-laenge); }
              /* aufraeumen: */
	      is_ipr=1;
	      (map[0][0].name) = (map[0][0].name) - 2*laenge -3;
	      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
	      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
					 run->name=aussen; run->invers=nil; }
	      run=run->next->invers->next; run->name=aussen; run->invers=nil;

	    }   /* ende if ...*/
	  } /* ende sonderfall naechste_stelle==0-sequenz */



    /* erst nur 6-Ecke */
    if (sechsecke >= laenge)
      { 
      naechste=sq.kanten[i];
      berechne_sequenz(&localseq,sq,i,0);
      if (localseq.k_marks[0])
      {
      if (laenge==1) { add_polygon(6,map,naechste,&naechste); nextmark=naechste;
                       localseq.kanten[0]=nextmark; 
		       localseq.kanten[localseq.laenge-1]=naechste->prev->invers->prev; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<laenge; j++)  add_polygon(6,map,naechste,&naechste); 
               localseq.kanten[0]=nextmark; localseq.kanten[1]=naechste; }
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-laenge);
	     baue_auf(map, localseq, sechsecke-laenge); }
      /* aufraeumen: */
      (map[0][0].name) = (map[0][0].name) - 2*laenge -1;

      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
    }/* ende if kanonisch */
      }   /* ende if ...*/



    /* dann ein 5- und 6-Ecke */
    if (sechsecke >= laenge-1)
      { 
      naechste=sq.kanten[i];
      berechne_sequenz(&localseq,sq,i,1); 
      if (localseq.k_marks[0])
      {
      if (laenge==1) { add_polygon(5,map,naechste,&naechste); nextmark=naechste; 
                       localseq.kanten[0]=nextmark; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<laenge-1; j++)  add_polygon(6,map,naechste,&naechste);  
               add_polygon(5,map,naechste,&naechste);  
               localseq.kanten[0]=nextmark; }
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-laenge+1);
	     baue_auf(map, localseq, sechsecke-laenge+1); }
      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*laenge;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
    }/* ende if kanonisch */
      }   /* ende if ... */

    /* dann eventuell zwei 5- und der Rest 6-Ecke um es zu 0-Sequenz zu machen */
    if ((laenge>=2) && (sechsecke >= laenge-2) && (sq.laenge==2))
      { 
      naechste=sq.kanten[i];
      berechne_sequenz(&localseq,sq,i,2);
      add_polygon(5,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
      for (j=1; j<laenge-1; j++)  add_polygon(6,map,naechste,&naechste);  
      add_polygon(5,map,naechste,&naechste); 
      localseq.kanten[0]=nextmark;
      check_mark_und_schreibe(map,nextmark,localseq.sequenz[0],sechsecke-laenge+2);

      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*laenge + 1;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if */
    }/* ende laenge != 0 */
   } /* ende for */

} /* ende if sequenzlaenge >=2 */

else /* d.h. sequenzlaenge==1 */
{
laenge=sq.sequenz[0];

/* erst nur 6-Ecke */
if (laenge && (sechsecke >= (laenge+1)))
 { 
 naechste=sq.kanten[0];
 berechne_sequenz(&localseq,sq,0,0);
 for (j=0; j<=laenge; j++)  add_polygon(6,map,naechste,&naechste);  
 nextmark=naechste;
 localseq.kanten[0]=nextmark;
 schreibe_auf(map,localseq,sechsecke-laenge-1);
 baue_auf(map, localseq, sechsecke-laenge-1); 
 /* aufraeumen: */
 (map[0][0].name) = (map[0][0].name) - 2*laenge -3;

      run=sq.kanten[0]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if */

/* dann ein 5- und 6-Ecke */
if (laenge && (sechsecke >= laenge))
  {
  naechste=sq.kanten[0];
  berechne_sequenz(&localseq,sq,0,1);
  for (j=0; j<laenge; j++)  add_polygon(6,map,naechste,&naechste);  
  add_polygon(5,map,naechste,&naechste); 
  nextmark=naechste;
  /* das ist zwar zwangslaeufig kanonisch, aber trotzdem: */
  localseq.kanten[0]=nextmark; 
  check_mark_und_schreibe(map,nextmark,localseq.sequenz[0],sechsecke-laenge);
  /* aufraeumen: */
  is_ipr=1;
  (map[0][0].name) = (map[0][0].name) - 2*laenge -2;
  run=sq.kanten[0]; run->name=aussen; run->invers=nil;
  for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
			     run->name=aussen; run->invers=nil; }
      }   /* ende if */


} /* ende else */

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x0, 0xf85c(%rip)      # 0x15191
je 0x5944
cmpb $0x0, 0xf826(%rip)      # 0x15164
je 0x68a7
leaq 0x150(%rsp), %rsi
movslq (%rsi), %rcx
cmpq $0x2, %rcx
movq %r14, 0x78(%rsp)
jl 0x669f
leaq -0x1(%rcx), %rax
leal 0x2(%r14), %edx
movl %edx, 0x94(%rsp)
leal -0x1(%r14), %edx
movl %edx, 0x90(%rsp)
movq %rax, 0xf8(%rsp)
movl %eax, %eax
movq %rax, 0x100(%rsp)
leaq 0x98(%rsp), %rbp
xorl %r8d, %r8d
movq %rcx, 0x108(%rsp)
testq %r8, %r8
je 0x59ae
cmpb $0x0, 0x58(%rsi,%r8)
jne 0x68a7
movl 0x4(%rsi,%r8,4), %r12d
leaq 0x1(%r8), %r13
testl %r12d, %r12d
movq %r8, 0x70(%rsp)
movq %r13, 0x110(%rsp)
je 0x5b19
cmpq 0x100(%rsp), %r8
movq %r13, %rax
movl $0x0, %edx
cmoveq %rdx, %rax
cmpl $0x2, %ecx
je 0x5fc9
cmpl $0x0, 0x4(%rsi,%rax,4)
jne 0x5fc9
cmpl %r12d, %r14d
jle 0x5e5c
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rbp
movq %rbp, %rcx
callq 0x4641
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r14
testl %r12d, %r12d
jle 0x5a53
movl %r12d, %r13d
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r13d
jne 0x5a39
movq %r14, %rdi
leaq 0x98(%rsp), %rbp
movq %rbp, %rsi
callq 0x4d97
cmpb $0x0, 0xf0(%rsp)
je 0x5aad
movl %r12d, %r14d
notl %r14d
addl 0x78(%rsp), %r14d
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5917
movzwl 0x2(%rbx), %eax
leal (%r12,%r12), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x4, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
jle 0x5e30
movl %r12d, %eax
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x5aed
jmp 0x5e42
cmpq 0xf8(%rsp), %r8
jge 0x5c85
cmpl $0x0, 0x4(%rsi,%r13,4)
jne 0x5c85
testl %r14d, %r14d
jle 0x5be1
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
callq 0x4641
movq 0x68(%rsp), %rdi
movq %rbp, %rsi
callq 0x4d97
cmpb $0x0, 0xf0(%rsp)
je 0x5bac
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl 0x90(%rsp), %r12d
movl %r12d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5917
addw $-0x4, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
callq 0x4641
movq 0x68(%rsp), %rdi
movq %rbp, %rsi
callq 0x4d97
cmpb $0x0, 0xf0(%rsp)
je 0x5c49
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5917
movb $0x1, 0xf514(%rip)      # 0x15164
addw $-0x3, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
cmpl $0x2, (%rsi)
jne 0x6681
cmpq $0x1, %r8
jne 0x68b9
movl 0x4(%rsi), %r12d
leal 0x2(%r12), %r13d
movl %r14d, %eax
subl %r13d, %eax
movl %eax, 0x8c(%rsp)
movq %r13, 0x80(%rsp)
jl 0x5df4
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
callq 0x4641
movq 0x68(%rsp), %r14
cmpl $0x1, %r13d
je 0x5d2b
movq 0x18(%r14), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r14
testl %r12d, %r12d
js 0x5d2b
leal 0x1(%r12), %r13d
leaq 0x68(%rsp), %rbp
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r13d
jne 0x5d01
leaq 0x98(%rsp), %rbp
movq 0x80(%rsp), %r13
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4d97
cmpb $0x0, 0xf0(%rsp)
je 0x5d7a
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl 0x8c(%rsp), %r14d
movl %r14d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5917
movzwl 0x2(%rbx), %eax
leal (,%r13,2), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x2, %eax
movw %ax, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
testl %r12d, %r12d
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
jle 0x5df4
movl %r12d, %ecx
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
movq $0x0, 0x28(%rax)
decl %ecx
jne 0x5dce
cmpl %r12d, %r14d
jle 0x6568
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
cmpl $0x1, %r13d
jne 0x642e
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
callq 0x4641
movq 0x68(%rsp), %r14
jmp 0x649e
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
movq $0x0, 0x28(%rax)
movl %r14d, %r13d
subl %r12d, %r13d
jl 0x5fc9
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rbp
movq %rbp, %rcx
callq 0x4641
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x80(%rsp)
cmpl $0x2, %r12d
jl 0x5ec8
leal -0x1(%r12), %r14d
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r14d
jne 0x5eae
movq 0x68(%rsp), %rdx
movl $0x5, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
movq 0x80(%rsp), %rdi
leaq 0x98(%rsp), %rbp
movq %rbp, %rsi
callq 0x4d97
cmpb $0x0, 0xf0(%rsp)
je 0x5f31
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5917
movb $0x1, 0xf22c(%rip)      # 0x15164
movzwl 0x2(%rbx), %eax
leal (%r12,%r12), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x3, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
jle 0x5f9d
movl %r12d, %eax
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x5f74
jmp 0x5faf
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
movq $0x0, 0x28(%rax)
movl %r14d, %r13d
subl %r12d, %r13d
jl 0x6155
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
leaq 0x150(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %r8d, %esi
xorl %edx, %edx
callq 0x4942
movq 0x70(%rsp), %r8
leaq 0x150(%rsp), %rsi
cmpb $0x0, 0xf0(%rsp)
je 0x6155
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
callq 0x4641
movq 0x68(%rsp), %rax
cmpl $0x1, %r12d
jne 0x6060
movq %rax, 0xb8(%rsp)
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movslq 0x98(%rsp), %rcx
movq %rax, 0xb0(%rsp,%rcx,8)
jmp 0x60c4
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x80(%rsp)
leaq 0x68(%rsp), %rbp
jle 0x609a
leal -0x1(%r12), %r14d
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r14d
jne 0x6080
movq 0x80(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x78(%rsp), %r14
leaq 0x98(%rsp), %rbp
cmpb $0x0, 0xf0(%rsp)
je 0x6100
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5917
leal (%r12,%r12), %eax
notl %eax
addw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
jle 0x6155
movl %r12d, %eax
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x612e
leal -0x1(%r12), %eax
cmpl %r14d, %eax
jg 0x62ef
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
leaq 0x150(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %r8d, %esi
movl $0x1, %edx
callq 0x4942
movq 0x70(%rsp), %r8
leaq 0x150(%rsp), %rsi
cmpb $0x0, 0xf0(%rsp)
je 0x62ef
cmpl $0x1, %r12d
jne 0x61d8
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
callq 0x4641
movq 0x68(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0x6260
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rbp
movq %rbp, %rcx
callq 0x4641
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x80(%rsp)
cmpl $0x3, %r12d
jl 0x622e
leal -0x2(%r12), %r14d
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r14d
jne 0x6214
movq 0x68(%rsp), %rdx
movl $0x5, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
movq 0x80(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x78(%rsp), %r14
leaq 0x98(%rsp), %rbp
incl %r13d
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5917
movb $0x1, 0xeec8(%rip)      # 0x15164
leal (%r12,%r12), %eax
subw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
jle 0x62ef
movl %r12d, %eax
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x62c8
cmpl $0x2, %r12d
jl 0x6681
leal -0x2(%r12), %r13d
cmpl %r14d, %r13d
jg 0x6681
cmpl $0x2, (%rsi)
jne 0x6681
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %r8d, %esi
movl $0x2, %edx
callq 0x4942
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rbp
movq %rbp, %rcx
callq 0x4641
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r14
cmpl $0x2, %r12d
je 0x637e
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r13d
jne 0x6364
movq 0x68(%rsp), %rdx
movl $0x5, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
movq %r14, 0xb8(%rsp)
movl 0x9c(%rsp), %edx
movl 0x94(%rsp), %ecx
subl %r12d, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57f6
movb $0x1, 0xeda6(%rip)      # 0x15164
movzwl 0x2(%rbx), %eax
leal (%r12,%r12), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
cmpl $0x2, %r12d
movl $0x1, %eax
cmovll %eax, %r12d
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
leaq 0x98(%rsp), %rbp
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %r12d
jne 0x6401
jmp 0x6681
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rbp
movq %rbp, %rcx
callq 0x4641
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r14
testl %r12d, %r12d
jle 0x6479
movl %r12d, %r13d
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r13d
jne 0x645f
movq 0x68(%rsp), %rdx
movl $0x5, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
leaq 0x98(%rsp), %rbp
movq 0x80(%rsp), %r13
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4d97
cmpb $0x0, 0xf0(%rsp)
je 0x64f0
movl 0x8c(%rsp), %r14d
incl %r14d
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5917
movb $0x1, 0xec6d(%rip)      # 0x15164
leal (,%r13,2), %eax
notl %eax
addw %ax, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
testl %r12d, %r12d
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
movq 0x70(%rsp), %r8
jle 0x6568
movl %r12d, %ecx
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
movq $0x0, 0x28(%rax)
decl %ecx
jne 0x6542
movl %r14d, %r13d
subl %r12d, %r13d
jl 0x6681
movq 0x20(%rsi,%r8,8), %r15
movq %r15, 0x68(%rsp)
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rbp
movq %rbp, %rcx
callq 0x4641
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x70(%rsp)
testl %r12d, %r12d
jle 0x65ce
movl %r12d, %r14d
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
decl %r14d
jne 0x65b4
movq 0x68(%rsp), %rdx
movl $0x5, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x4641
movq 0x70(%rsp), %r14
movq %r14, %rdi
leaq 0x98(%rsp), %rbp
movq %rbp, %rsi
callq 0x4d97
movl 0x9c(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %ecx
callq 0x57f6
movb $0x1, 0xeb4d(%rip)      # 0x15164
movq 0x80(%rsp), %rax
addl %eax, %eax
subw %ax, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
testl %r12d, %r12d
movq 0x78(%rsp), %r14
leaq 0x150(%rsp), %rsi
jle 0x6681
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
movq $0x0, 0x28(%rax)
decl %r12d
jne 0x665a
movq 0x108(%rsp), %rcx
movq 0x110(%rsp), %r8
cmpq %rcx, %r8
jne 0x599d
jmp 0x68a7
movl 0x4(%rsi), %r15d
testl %r15d, %r15d
sete %al
cmpl %r15d, %r14d
setle %cl
orb %al, %cl
jne 0x67b2
movq 0x20(%rsi), %r12
movq %r12, 0x68(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x98(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4942
testl %r15d, %r15d
js 0x6703
leal 0x1(%r15), %ebp
leaq 0x68(%rsp), %r14
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x4641
decl %ebp
jne 0x66ea
movq 0x68(%rsp), %rax
leaq 0x98(%rsp), %r14
movq %rax, 0x20(%r14)
movl %r15d, %ebp
notl %ebp
movq 0x78(%rsp), %r13
addl %r13d, %ebp
movl $0xc, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56bb
movl $0xc, %ecx
movq %rsp, %rdi
movq %r14, %rsi
movq %r13, %r14
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5917
movzwl 0x2(%rbx), %eax
leal (%r15,%r15), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x3, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
testl %r15d, %r15d
leaq 0x150(%rsp), %rsi
jle 0x67b2
movl %r15d, %eax
movq 0x20(%r12), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r12
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
decl %eax
jne 0x6788
testl %r15d, %r15d
sete %al
subl %r15d, %r14d
setl %cl
orb %al, %cl
jne 0x68a7
movq %r14, %r13
movq 0x20(%rsi), %r12
movq %r12, 0x68(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x98(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4942
testl %r15d, %r15d
jle 0x6817
leaq 0x68(%rsp), %r14
movl %r15d, %ebp
movq 0x68(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x4641
decl %ebp
jne 0x67fe
leaq 0x68(%rsp), %r14
movq (%r14), %rdx
movl $0x5, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x4641
movq (%r14), %rsi
movq %rsi, 0xb8(%rsp)
movl 0x9c(%rsp), %edx
movq %rbx, %rdi
movl %r13d, %ecx
callq 0x57f6
movb $0x1, 0xe911(%rip)      # 0x15164
movzwl 0x2(%rbx), %eax
leal (%r15,%r15), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x2, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
testl %r15d, %r15d
jle 0x68a7
movq 0x20(%r12), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r12
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
decl %r15d
jne 0x687c
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x16e3