// File: giovifazi[P]knossos-bloodbath/main.cpp
// Function: main
int main()
{
   	printTitle();

   	srand(time(0));        // Random seed per partite pseudocasuali

	Map map_game(1,1);     // Creo una mappa con w=1 e h=1 ma ancora vuota
	map_game.init(1);      // Inizializza la mappa con valore 1 nella posizione (0,0)
	Node node_orig(0,0);   // Creo il nodo iniziale

	//Controllo se i giocatori vogliono giocare
  	if (!loadMenu())
		return 0;		

	int NP = setPlayers();        	//imposto il numero di giocatori

	Player *players[NP];	      	   //creo n giocatori in array dinamico

	for (int i=0; i<NP; i++)      	//inizializzo tutti i giocatori
	{
		players[i] = new Player(setName(i+1),50,10,i+1);   // setName e` nel Menu.cpp
		players[i]->pos = &node_orig;                      // imposto la posizione di tutti giocatori nel nodo iniziale
	}

   // Stampa grafica e narrazione di entrata nel labirinto
   printEntrance();

   // Metto nella mappa grafica la somma dei numeri assegnati ai players
	map_game.changeValue(0,0, ((NP*(NP+1))/2) +1, NP);

	// Inizio vera e propria partita
	char cmd_player;		         // carattere di input del giocatore
	int alive_players = NP;		   // Numero di giocatori in vita
	std::string allwd_mov = "nseox";   // stringa con i caratteri validi per giocare

   int z;                  // in base al valore di z stampo un hud differente
   int death;              // controlla se un giocatore e' morto di "morte naturale" o se in seguito ad un combattimento
   bool mov_newn;          // controlla movimento verso un nodo esistente o appena creato
   bool ignore = false;    // controlla per stabilire se usare cin.ignore o meno 

	// Loop dei turni
	while (true)
	{
		// Scorre array giocatori per far eseguire i turni
		for (int j=0; j<NP; j++)
		{
			// Fa turni finche` non c e` un solo vincitore
			if (alive_players > 1)
			{
				//Fa fare il turno solo ai giocatori ancora in vita
				if (players[j] != NULL && players[j]->is_alive())
				{
	       death=0;		//reimposto la morte naturale, durante i turni precedenti potrebbe essere stata cambiata
               map_game.set_Turn(players[j]->pos->get_x(), players[j]->pos->get_y(),true); // Imposta nella mappa dove stampare le {} per il turno corrente
					map_game.draw(NP);				
					map_game.set_Turn(players[j]->pos->get_x(), players[j]->pos->get_y(),false);// Toglie nella mappa dove avviene il turno corrente

               if (map_game.getPresAt(players[j]->pos->get_x(), players[j]->pos->get_y())!= 1)
                  z=1;     // se nel nodo c'e' un solo player indico che x e` per cercare oggetti 
               else 
                  z=0;     // ..per combattere altrimenti


					hud_print(players[j], allwd_mov, z);			// Stampa comandi player
					cmd_player = get_player_input(allwd_mov);    // filtra input giocatore e lo ritorna in cmd_player, get_player_input e` in game.cpp
	
					if (cmd_player == 'x')  // Se esamino/combatto
               {	
                  ignore = true;    // stampa ignore per comodita gameplay
						
						//Se c`e' un solo giocatore nella stanza, esamina la stanza
						if (map_game.getPresAt(players[j]->pos->get_x(), players[j]->pos->get_y())== 1)
                     hud_action(players[j]->diceRoll_or());   // Lancia il dado per esaminare stanze visitate, diceRoll_or() mi restituisce un'intero per la stampa hud_action
						//Altrimenti decide se combattere
						else
						if (battleChoice()) {
								death=players[j]->engage_battle(&players[0],  map_game, NP, j, node_orig, alive_players);
                        ignore = true;
                  }
else { ignore = false;}
               }
					//Se l'input e' un azione di movimento (n s e o)
					else
               {
						//Muove il giocatore secondo l'input
						mov_newn = players[j]->Player_move(cmd_player, map_game, node_orig);
										
						//Controllo se ci sono altri giocatori nel nodo in cui mi sto muovendo
						if (map_game.getPresAt(players[j]->pos->get_x(), players[j]->pos->get_y()) > 1)
						{
							if (battleChoice()){    // battleChoice fa scegliere se combattere
								death=players[j]->engage_battle(&players[0],  map_game, NP, j, node_orig, alive_players );					
					         ignore = true;
					      } else { ignore = false; }
                  }

               }

                                        
					//Controllo eventuale morte del giocatore[j] alla fine del suo turno
					if (!players[j]->is_alive())
					{
                  hud_death(players[j]->getName(), death);  // Grafica della morte

						players[j]->remove_from_map(map_game);    // Rimuove il simbolo dalla mappa grafica
						players[j]->pos = NULL;                   // cancella il puntatore della pos ai nodi
						players[j] = NULL;                        // cancella il puntatore a giocatore
                  
                  alive_players--;                          // Segna un giocatore vivo in meno
					}
           
               // FINE TURNO stampo mappa per rispettare le specifiche del progetto

               if (players[j]==NULL)                            //caso in cui il giocatore sia morto durante il suo turno
               {
                  map_game.draw(NP);               
                  std::cout << "\n\nPremi invio per terminare il turno";
                  std::cin.get();
               }
               else 
               {
                  std::cout << "Fine del turno di " << players[j]->getName() << "\n\n";
                  map_game.draw(NP);
          

 
	  	// Evita di dover premere due volte invio a fine turno in certi casi
	  	if (!(mov_newn /*|| map_game.getPresAt(players[j]->pos->get_x(), players[j]->pos->get_y()) > 1*/))
                     if (!ignore)
			std::cin.ignore(); 
                  
                  std::cout << "\n\nPremi invio per terminare il turno ";
                  std::cin.get();
               }
               
               // reimposto queste variabili per cin.ignore
               ignore = false;
               mov_newn = false;
            }

            // Spazi per separare grafica
            for (int r=0; r < 40; r++)
               std::cout << "\n";

         }// if alive_players > 1
	
		   if (alive_players == 1)    // In caso di vittoria di un giocatore
         {			   
            // scorre l array di giocatori per trovare quello che ha vinto
            for (int j=0; j<NP; j++)
            {
               if (players[j] != NULL)
               {  
                  // Stampa mappa con ultimo sopravvissuto
                  map_game.draw(NP);
                 
                  // Stampa grafica e narrazione di uscita dal labirinto
				  printExit();

				  std::cout
                  << players[j]->getName() << " vince!\n"
                  << "Premi invio per chiudere il gioco";
                 
                  std::cin.get();
               }
            }
           
            // Cancella la mappa di gioco con garbage collection
            map_game.delete_map(true);
            return 0;
        
         }//if alive_players ==1
	   
	   }//for j=0.. np.. etc
  	
  	}//while true
 

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl $0x0, -0x4(%rbp)
callq 0x8360
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
movl %eax, %edi
callq 0x2190
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x4280
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x4390
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x34d0
callq 0xa790
testb $0x1, %al
jne 0x26a7
movl $0x0, -0x4(%rbp)
jmp 0x316b
callq 0xae20
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x58(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x188(%rbp)
movq %rcx, %rsp
movq %rax, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x27de
movl $0x58, %edi
callq 0x21b0
movq %rax, -0x190(%rbp)
movb $0x1, -0x95(%rbp)
movl -0x64(%rbp), %esi
incl %esi
leaq -0x88(%rbp), %rdi
callq 0xb0b0
jmp 0x2717
movq -0x190(%rbp), %rdi
movl -0x64(%rbp), %r8d
incl %r8d
leaq -0x88(%rbp), %rsi
movl $0x32, %edx
movl $0xa, %ecx
callq 0x8830
jmp 0x273d
movq -0x188(%rbp), %rax
movq -0x190(%rbp), %rdx
movb $0x0, -0x95(%rbp)
movslq -0x64(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
leaq -0x88(%rbp), %rdi
callq 0x2100
movq -0x188(%rbp), %rax
movslq -0x64(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq -0x48(%rbp), %rcx
movq %rcx, 0x50(%rax)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x26e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x27bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2100
testb $0x1, -0x95(%rbp)
jne 0x27c8
jmp 0x27d9
movq -0x190(%rbp), %rdi
movl $0x58, %esi
callq 0x21c0
jmp 0x3173
callq 0x84d0
movl -0x4c(%rbp), %r8d
movl %r8d, %eax
incl %eax
movl %r8d, %ecx
imull %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %eax, %ecx
sarl %ecx
incl %ecx
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4f50
movl -0x4c(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x2330
movq -0x198(%rbp), %rdx
leaq 0x97d0(%rip), %rsi      # 0xc004
leaq -0xc0(%rbp), %rdi
callq 0x3180
jmp 0x2842
leaq -0xc1(%rbp), %rdi
callq 0x2200
movb $0x0, -0xce(%rbp)
jmp 0x2857
movl $0x0, -0xd4(%rbp)
movl -0xd4(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x3158
cmpl $0x1, -0x9c(%rbp)
jle 0x3003
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2fc6
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x89a0
movb %al, -0x199(%rbp)
jmp 0x28b5
movb -0x199(%rbp), %al
testb $0x1, %al
jne 0x28c4
jmp 0x2fc6
movq -0x188(%rbp), %rax
movl $0x0, -0xcc(%rbp)
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3510
movl %eax, -0x1a0(%rbp)
jmp 0x28f1
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3530
movl %eax, -0x1a4(%rbp)
jmp 0x2914
movl -0x1a4(%rbp), %edx
movl -0x1a0(%rbp), %esi
leaq -0x20(%rbp), %rdi
movl $0x1, %ecx
callq 0x5050
jmp 0x2930
movl -0x4c(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x47b0
jmp 0x293e
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3510
movl %eax, -0x1a8(%rbp)
jmp 0x2961
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3530
movl %eax, -0x1ac(%rbp)
jmp 0x2984
movl -0x1ac(%rbp), %edx
movl -0x1a8(%rbp), %esi
leaq -0x20(%rbp), %rdi
xorl %ecx, %ecx
callq 0x5050
jmp 0x299d
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3510
movl %eax, -0x1b0(%rbp)
jmp 0x29c0
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3530
movl %eax, -0x1b4(%rbp)
jmp 0x29e3
movl -0x1b4(%rbp), %edx
movl -0x1b0(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x42a0
movl %eax, -0x1b8(%rbp)
jmp 0x2a00
movl -0x1b8(%rbp), %eax
cmpl $0x1, %eax
je 0x2a51
movl $0x1, -0xc8(%rbp)
jmp 0x2a5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xc1(%rbp), %rdi
callq 0x2200
jmp 0x3173
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x315d
movl $0x0, -0xc8(%rbp)
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x1c0(%rbp)
leaq -0xf8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x20b0
jmp 0x2a89
movq -0x1c0(%rbp), %rdi
movl -0xc8(%rbp), %edx
leaq -0xf8(%rbp), %rsi
callq 0x51e0
jmp 0x2aa4
leaq -0xf8(%rbp), %rdi
callq 0x2100
leaq -0x118(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x20b0
jmp 0x2ac5
leaq -0x118(%rbp), %rdi
callq 0xb8d0
movb %al, -0x1c1(%rbp)
jmp 0x2ad9
movb -0x1c1(%rbp), %al
movb %al, -0x96(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x2100
movsbl -0x96(%rbp), %eax
cmpl $0x78, %eax
jne 0x2c6b
movq -0x188(%rbp), %rax
movb $0x1, -0xce(%rbp)
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3510
movl %eax, -0x1c8(%rbp)
jmp 0x2b2b
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3530
movl %eax, -0x1cc(%rbp)
jmp 0x2b4e
movl -0x1cc(%rbp), %edx
movl -0x1c8(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x42a0
movl %eax, -0x1d0(%rbp)
jmp 0x2b6b
movl -0x1d0(%rbp), %eax
cmpl $0x1, %eax
jne 0x2bed
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x9660
movl %eax, -0x1d4(%rbp)
jmp 0x2b95
movl -0x1d4(%rbp), %edi
callq 0x7220
jmp 0x2ba2
jmp 0x2c66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x2100
jmp 0x315d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x2100
jmp 0x315d
callq 0xb740
movb %al, -0x1d5(%rbp)
jmp 0x2bfa
movb -0x1d5(%rbp), %al
testb $0x1, %al
jne 0x2c06
jmp 0x2c5d
movq -0x188(%rbp), %rsi
movslq -0xd4(%rbp), %rax
movl %eax, %r8d
movq (%rsi,%rax,8), %rdi
movl -0x4c(%rbp), %ecx
subq $0x10, %rsp
movq %rsp, %rax
leaq -0x9c(%rbp), %rdx
movq %rdx, (%rax)
leaq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %r9
callq 0x8ea0
addq $0x10, %rsp
movl %eax, -0x1dc(%rbp)
jmp 0x2c48
movl -0x1dc(%rbp), %eax
movl %eax, -0xcc(%rbp)
movb $0x1, -0xce(%rbp)
jmp 0x2c64
movb $0x0, -0xce(%rbp)
jmp 0x2c66
jmp 0x2d91
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movsbl -0x96(%rbp), %esi
leaq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x89d0
movb %al, -0x1dd(%rbp)
jmp 0x2c99
movq -0x188(%rbp), %rax
movb -0x1dd(%rbp), %cl
andb $0x1, %cl
movb %cl, -0xcd(%rbp)
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3510
movl %eax, -0x1e4(%rbp)
jmp 0x2ccb
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rdi
callq 0x3530
movl %eax, -0x1e8(%rbp)
jmp 0x2cee
movl -0x1e8(%rbp), %edx
movl -0x1e4(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x42a0
movl %eax, -0x1ec(%rbp)
jmp 0x2d0b
movl -0x1ec(%rbp), %eax
cmpl $0x1, %eax
jle 0x2d8f
callq 0xb740
movb %al, -0x1ed(%rbp)
jmp 0x2d23
movb -0x1ed(%rbp), %al
testb $0x1, %al
jne 0x2d2f
jmp 0x2d86
movq -0x188(%rbp), %rsi
movslq -0xd4(%rbp), %rax
movl %eax, %r8d
movq (%rsi,%rax,8), %rdi
movl -0x4c(%rbp), %ecx
subq $0x10, %rsp
movq %rsp, %rax
leaq -0x9c(%rbp), %rdx
movq %rdx, (%rax)
leaq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %r9
callq 0x8ea0
addq $0x10, %rsp
movl %eax, -0x1f4(%rbp)
jmp 0x2d71
movl -0x1f4(%rbp), %eax
movl %eax, -0xcc(%rbp)
movb $0x1, -0xce(%rbp)
jmp 0x2d8d
movb $0x0, -0xce(%rbp)
jmp 0x2d8f
jmp 0x2d91
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x89a0
movb %al, -0x1f5(%rbp)
jmp 0x2db0
movb -0x1f5(%rbp), %al
testb $0x1, %al
jne 0x2e7a
jmp 0x2dc0
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x138(%rbp), %rdi
callq 0x8900
jmp 0x2de0
movl -0xcc(%rbp), %esi
leaq -0x138(%rbp), %rdi
callq 0x8190
jmp 0x2df4
leaq -0x138(%rbp), %rdi
callq 0x2100
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8e20
jmp 0x2e1d
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq $0x0, 0x50(%rcx)
movslq -0xd4(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x9c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x2e7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x2100
jmp 0x315d
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x2ec5
movl -0x4c(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x47b0
jmp 0x2e9d
movq 0x1112c(%rip), %rdi     # 0x13fd0
leaq 0x915f(%rip), %rsi      # 0xc00a
callq 0x21a0
jmp 0x2eb2
movq 0x11127(%rip), %rdi     # 0x13fe0
callq 0x2250
jmp 0x2ec0
jmp 0x2fb8
movq 0x11104(%rip), %rdi     # 0x13fd0
leaq 0x915c(%rip), %rsi      # 0xc02f
callq 0x21a0
movq %rax, -0x200(%rbp)
jmp 0x2ee1
movq -0x188(%rbp), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x158(%rbp), %rdi
callq 0x8900
jmp 0x2f01
movq -0x200(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0x2170
movq %rax, -0x208(%rbp)
jmp 0x2f1d
movq -0x208(%rbp), %rdi
leaq 0xda4d(%rip), %rsi      # 0x10978
callq 0x21a0
jmp 0x2f32
leaq -0x158(%rbp), %rdi
callq 0x2100
movl -0x4c(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x47b0
jmp 0x2f4c
testb $0x1, -0xcd(%rbp)
jne 0x2f93
testb $0x1, -0xce(%rbp)
jne 0x2f91
movq 0x1107b(%rip), %rdi     # 0x13fe0
callq 0x2350
jmp 0x2f6c
jmp 0x2f91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x2100
jmp 0x315d
jmp 0x2f93
movq 0x11036(%rip), %rdi     # 0x13fd0
leaq 0x90a1(%rip), %rsi      # 0xc042
callq 0x21a0
jmp 0x2fa8
movq 0x11031(%rip), %rdi     # 0x13fe0
callq 0x2250
jmp 0x2fb6
jmp 0x2fb8
movb $0x0, -0xce(%rbp)
movb $0x0, -0xcd(%rbp)
movl $0x0, -0x15c(%rbp)
cmpl $0x28, -0x15c(%rbp)
jge 0x3001
movq 0x10ff0(%rip), %rdi     # 0x13fd0
leaq 0xd992(%rip), %rsi      # 0x10979
callq 0x21a0
jmp 0x2fee
jmp 0x2ff0
movl -0x15c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x15c(%rbp)
jmp 0x2fd0
jmp 0x3003
cmpl $0x1, -0x9c(%rbp)
jne 0x3142
movl $0x0, -0x160(%rbp)
movl -0x160(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x3116
movq -0x188(%rbp), %rax
movslq -0x160(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3100
movl -0x4c(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x47b0
jmp 0x3050
callq 0x8680
jmp 0x3057
movq -0x188(%rbp), %rax
movslq -0x160(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x180(%rbp), %rdi
callq 0x8900
jmp 0x3077
movq 0x10f52(%rip), %rdi     # 0x13fd0
leaq -0x180(%rbp), %rsi
callq 0x2170
movq %rax, -0x210(%rbp)
jmp 0x3093
movq -0x210(%rbp), %rdi
leaq 0x8fc7(%rip), %rsi      # 0xc068
callq 0x21a0
movq %rax, -0x218(%rbp)
jmp 0x30af
movq -0x218(%rbp), %rdi
leaq 0x8fb4(%rip), %rsi      # 0xc071
callq 0x21a0
jmp 0x30c4
leaq -0x180(%rbp), %rdi
callq 0x2100
movq 0x10f09(%rip), %rdi     # 0x13fe0
callq 0x2250
jmp 0x30de
jmp 0x3100
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x2100
jmp 0x315d
jmp 0x3102
movl -0x160(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x160(%rbp)
jmp 0x301a
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x4450
jmp 0x3126
movl $0x0, -0x4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2100
movq -0x58(%rbp), %rax
movq %rax, %rsp
jmp 0x316b
jmp 0x3144
movl -0xd4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd4(%rbp)
jmp 0x2861
jmp 0x2855
leaq -0xc0(%rbp), %rdi
callq 0x2100
jmp 0x3173
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x2320
nop