LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: janthonyo[P]Redes-Practicas/message.cc
// Function: nextTurnMessage(int*, domino&)
void nextTurnMessage(int *i, domino& game)
{
    char mensaje[MSG_SIZE];

    //Se informa de paso de turno
    if(*i == game.getSocketP1()){
        strcpy(mensaje, "+Ok. Turno de partida.\n\n");
        send(game.getSocketP2(), mensaje, strlen(mensaje), 0);

        strcpy(mensaje, "+Ok. Turno del otro jugador.\n\n");
        send(game.getSocketP1(), mensaje, strlen(mensaje), 0);
    }
    else if (*i == game.getSocketP2()) {
        strcpy(mensaje, "+Ok. Turno de partida.\n\n");
        send(game.getSocketP1(), mensaje, strlen(mensaje), 0);

        strcpy(mensaje, "+Ok. Turno del otro jugador.\n\n");
        send(game.getSocketP2(), mensaje, strlen(mensaje), 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x114(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7b30
movl %eax, %ecx
movl -0x114(%rbp), %eax
cmpl %ecx, %eax
jne 0xe2b3
leaq -0x110(%rbp), %rdi
leaq 0x45a3(%rip), %rsi      # 0x127b9
callq 0x3260
movq -0x10(%rbp), %rdi
callq 0x7b50
movl %eax, -0x134(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3140
movl -0x134(%rbp), %edi
movq -0x130(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3150
leaq -0x110(%rbp), %rdi
leaq 0x4569(%rip), %rsi      # 0x127d2
callq 0x3260
movq -0x10(%rbp), %rdi
callq 0x7b30
movl %eax, -0x124(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3140
movl -0x124(%rbp), %edi
movq -0x120(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3150
jmp 0xe380
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7b50
movl %eax, %ecx
movl -0x138(%rbp), %eax
cmpl %ecx, %eax
jne 0xe37e
leaq -0x110(%rbp), %rdi
leaq 0x44d3(%rip), %rsi      # 0x127b9
callq 0x3260
movq -0x10(%rbp), %rdi
callq 0x7b30
movl %eax, -0x154(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3140
movl -0x154(%rbp), %edi
movq -0x150(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3150
leaq -0x110(%rbp), %rdi
leaq 0x4499(%rip), %rsi      # 0x127d2
callq 0x3260
movq -0x10(%rbp), %rdi
callq 0x7b50
movl %eax, -0x144(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3140
movl -0x144(%rbp), %edi
movq -0x140(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3150
jmp 0xe380
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: salirCliente(int, fd_set*, int*, std::vector<cliente, std::allocator<cliente>>&)
void salirCliente(int socket, fd_set * readfds, int * numClientes, std::vector<cliente> &arrayClientes){

    char buffer[250];
    int j;

    close(socket);
    FD_CLR(socket,readfds);

    //Re-estructurar el array de clientes
    for (j = 0; j < (*numClientes) - 1; j++)
        if (arrayClientes[j].sd == socket)
            break;
    for (; j < (*numClientes) - 1; j++)
        (arrayClientes[j] = arrayClientes[j+1]);

    (*numClientes)--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x34a0
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x138(%rbp), %rdx
movl %eax, %ecx
movq -0x130(%rbp), %rax
movslq %ecx, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x124(%rbp)
movl -0x124(%rbp), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xf63e
movq -0x20(%rbp), %rdi
movslq -0x124(%rbp), %rsi
callq 0x70f0
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xf62b
jmp 0xf63e
jmp 0xf62d
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0xf5ff
jmp 0xf640
movl -0x124(%rbp), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xf6a4
movq -0x20(%rbp), %rdi
movl -0x124(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x70f0
movq %rax, -0x140(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x124(%rbp), %rsi
callq 0x70f0
movq -0x140(%rbp), %rsi
movq %rax, %rdi
movl $0xd4, %edx
callq 0x31f0
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0xf640
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax,%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: checkUser(char*)
bool checkUser(char buffer[])
{
	char user[100];
	char passwd[100];
	std::fstream dataFile;
	bool isUser = false;

	dataFile.open("Data-Clients.txt", std::fstream::in);

	// A la fuerza, cualquier cliente tendra que tener
	// un usuario y una contraseña para acceder al domino y,
	// por lo tanto en el fichero de datos deben aparecer ambos reflejados,
	// por lo que recorreremos el fichero guardando el valor
	// del nombre de usuario (user) y su password (passwd)

	while(!dataFile.eof())
	{
		dataFile >> user;
		dataFile >> passwd;

		if( strcmp(buffer, user) == 0 )
			isUser = true;
	}

	dataFile.close();

	return isUser;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
leaq -0x2f0(%rbp), %rdi
movq %rdi, -0x310(%rbp)
callq 0x3320
movq -0x310(%rbp), %rdi
movb $0x0, -0x2f1(%rbp)
leaq 0x320a(%rip), %rsi      # 0x12931
movl $0x8, %edx
callq 0x3240
jmp 0xf733
jmp 0xf735
movq -0x2f0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x2f0(%rbp,%rax), %rdi
callq 0x3470
movb %al, -0x311(%rbp)
jmp 0xf755
movb -0x311(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xf763
jmp 0xf7ca
leaq -0x2f0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x10b70
jmp 0xf775
leaq -0x2f0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x10b70
jmp 0xf78a
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3390
cmpl $0x0, %eax
jne 0xf7c5
movb $0x1, -0x2f1(%rbp)
jmp 0xf7c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x300(%rbp)
movl %eax, -0x304(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x30a0
jmp 0xf801
jmp 0xf735
leaq -0x2f0(%rbp), %rdi
callq 0x3060
jmp 0xf7d8
movb -0x2f1(%rbp), %al
movb %al, -0x312(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x30a0
movb -0x312(%rbp), %al
andb $0x1, %al
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
movq -0x300(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: registerUser(char*, char*)
bool registerUser(char rUser[], char rPasswd[])
{
	bool registerCompleted = false;
	std::fstream dataFile;

	if(!checkUser(rUser))
	{
		dataFile.open("Data-Clients.txt", std::fstream::out | std::fstream::app);
		dataFile << rUser << " " << rPasswd << "\n";
		dataFile.close();
		registerCompleted = true;
	}

	return registerCompleted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3320
movq -0x8(%rbp), %rdi
callq 0xf6f0
movb %al, -0x235(%rbp)
jmp 0xf844
movb -0x235(%rbp), %al
testb $0x1, %al
jne 0xf91d
jmp 0xf854
movl $0x10, %edi
movl $0x1, %esi
callq 0x10bc0
movl %eax, -0x23c(%rbp)
jmp 0xf86b
movl -0x23c(%rbp), %edx
leaq 0x30b9(%rip), %rsi      # 0x12931
leaq -0x228(%rbp), %rdi
callq 0x3240
jmp 0xf886
leaq -0x218(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3290
movq %rax, -0x248(%rbp)
jmp 0xf89f
movq -0x248(%rbp), %rdi
leaq 0x2ba3(%rip), %rsi      # 0x12450
callq 0x3290
movq %rax, -0x250(%rbp)
jmp 0xf8bb
movq -0x250(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3290
movq %rax, -0x258(%rbp)
jmp 0xf8d4
movq -0x258(%rbp), %rdi
leaq 0x2f34(%rip), %rsi      # 0x12816
callq 0x3290
jmp 0xf8e9
leaq -0x228(%rbp), %rdi
callq 0x3060
jmp 0xf8f7
movb $0x1, -0x11(%rbp)
jmp 0xf91d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x30a0
jmp 0xf943
movb -0x11(%rbp), %al
movb %al, -0x259(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x30a0
movb -0x259(%rbp), %al
andb $0x1, %al
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x3420
nop
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: verifyPassword(char*, char*)
bool verifyPassword(char cUser[], char cPasswd[])
{
	char user[100];
	char passwd[100];
	bool foundClient = false;
	bool correctPasswd = false;

	std::fstream dataFile;
	dataFile.open("Data-Clients.txt", std::fstream::in);

	while ((!dataFile.eof()) and (!foundClient))
	{
		dataFile >> user;
		dataFile >> passwd;

		if(strcmp(cUser, user) == 0)
		{
			foundClient = true;

			if(strcmp(cPasswd, passwd) == 0)
			{
				correctPasswd = true;
			}
		}
	}

	dataFile.close();

	return correctPasswd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp            # imm = 0x330
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0xf1(%rbp)
movb $0x0, -0xf2(%rbp)
leaq -0x308(%rbp), %rdi
movq %rdi, -0x320(%rbp)
callq 0x3320
movq -0x320(%rbp), %rdi
leaq 0x2f9f(%rip), %rsi      # 0x12931
movl $0x8, %edx
callq 0x3240
jmp 0xf99e
jmp 0xf9a0
movq -0x308(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x308(%rbp,%rax), %rdi
callq 0x3470
movb %al, -0x321(%rbp)
jmp 0xf9c0
movb -0x321(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x322(%rbp)
jne 0xf9e3
jmp 0xf9d5
movb -0xf1(%rbp), %al
xorb $-0x1, %al
movb %al, -0x322(%rbp)
movb -0x322(%rbp), %al
testb $0x1, %al
jne 0xf9f2
jmp 0xfa77
leaq -0x308(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x10b70
jmp 0xfa04
leaq -0x308(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x10b70
jmp 0xfa19
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3390
cmpl $0x0, %eax
jne 0xfa72
movb $0x1, -0xf1(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x3390
cmpl $0x0, %eax
jne 0xfa70
movb $0x1, -0xf2(%rbp)
jmp 0xfa70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x310(%rbp)
movl %eax, -0x314(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x30a0
jmp 0xfaae
jmp 0xfa72
jmp 0xf9a0
leaq -0x308(%rbp), %rdi
callq 0x3060
jmp 0xfa85
movb -0xf2(%rbp), %al
movb %al, -0x323(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x30a0
movb -0x323(%rbp), %al
andb $0x1, %al
addq $0x330, %rsp            # imm = 0x330
popq %rbp
retq
movq -0x310(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: matchmaking(std::vector<domino, std::allocator<domino>>)
int matchmaking(std::vector<domino> games)
{
	int gameAssigned = -1;

	for(int i = 0; i < (int) games.size(); i++)
	{
		if(gameAssigned == -1)
		{
			if(!games[i].has2players())
			{
				gameAssigned = i;
			}
		}
	}

	return gameAssigned;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xc070
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0xfb2b
cmpl $-0x1, -0xc(%rbp)
jne 0xfb1e
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x7420
movq %rax, %rdi
callq 0x7500
testb $0x1, %al
jne 0xfb1c
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfb1e
jmp 0xfb20
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfade
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: alternatePlayerStatus(domino&, std::vector<cliente, std::allocator<cliente>>&)
void alternatePlayerStatus(domino& game, std::vector<cliente>& arrayClientes)
{
	int sdplayer1 = game.getSocketP1();
	int sdplayer2 = game.getSocketP2();

	for (int i = 0; i < (int) arrayClientes.size(); i++)
	{
		if (arrayClientes[i].sd == sdplayer1)
        {
        	if (arrayClientes[i].status == 3)
        		arrayClientes[i].status = 4;

        	else
        		arrayClientes[i].status = 3;
        }

        else if (arrayClientes[i].sd == sdplayer2)
        {
        	if (arrayClientes[i].status == 3)
        		arrayClientes[i].status = 4;

        	else
        		arrayClientes[i].status = 3;
        }
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7b30
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7b50
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb4d0
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0xfc44
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xfbdf
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
cmpl $0x3, 0x4(%rax)
jne 0xfbc9
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
movl $0x4, 0x4(%rax)
jmp 0xfbdd
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
movl $0x3, 0x4(%rax)
jmp 0xfc34
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0xfc32
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
cmpl $0x3, 0x4(%rax)
jne 0xfc1c
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
movl $0x4, 0x4(%rax)
jmp 0xfc30
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x70f0
movl $0x3, 0x4(%rax)
jmp 0xfc32
jmp 0xfc34
jmp 0xfc36
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfb6f
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: userInWaitList(int, std::vector<int, std::allocator<int>>)
bool userInWaitList(int sd, std::vector <int> waitList)
{
	bool result = false;

	for(int i = 0; i < (int) waitList.size(); i++)
	{
		if(waitList[i] == sd)
			result = true;

	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0xd440
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x100bc
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x10c20
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x100af
movb $0x1, -0x11(%rbp)
jmp 0x100b1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1007e
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: managePostGame(std::vector<domino, std::allocator<domino>>&, int, std::vector<cliente, std::allocator<cliente>>&, int, int*)
void managePostGame(std::vector<domino> &partida, int pos, std::vector<cliente> &arrayClientes, int numClientes, int *numPartidas)
{
	for (int j = 0; j < numClientes; j++)
	{
	    if (arrayClientes[j].sd == partida[pos].getSocketP1())
	    {
	        // Cambiamos el estado para que puedan iniciar nueva partida
	        arrayClientes[j].status = 2;
	        arrayClientes[j].inGame = -1;
	    }

	    else if (arrayClientes[j].sd == partida[pos].getSocketP2())
	    {
	        // Cambiamos el estado para que puedan iniciar nueva partida
	        arrayClientes[j].status = 2;
	        arrayClientes[j].inGame = -1;
	    }
    }

    // Limpiamos la partida y la habilitamos para otros usuarios
    partida[pos].emptyBoard();
    (*numPartidas)--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x101c7
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x70f0
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7420
movq %rax, %rdi
callq 0x7b30
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x1015a
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x70f0
movl $0x2, 0x4(%rax)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x70f0
movl $0xffffffff, 0xd0(%rax) # imm = 0xFFFFFFFF
jmp 0x101b7
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x70f0
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7420
movq %rax, %rdi
callq 0x7b50
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jne 0x101b5
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x70f0
movl $0x2, 0x4(%rax)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x70f0
movl $0xffffffff, 0xd0(%rax) # imm = 0xFFFFFFFF
jmp 0x101b7
jmp 0x101b9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x100f1
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7420
movq %rax, %rdi
callq 0x7b70
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: checkPiece(int, char*, ficha&, char*&)
bool checkPiece(int i, char* buffer, ficha &auxFicha, char* &extremo)
{
    //Variables auxiliares
    int contNum = 0;
    char valorFicha[2];
    char* aux;

    //Sacamos "COLOCAR-FICHA" del buffer
    aux = strtok(buffer, " ,");

    // Sacamos la ficha y la posicion donde colocarla (izquierda/derecha)
    aux = strtok(NULL, " ,");   //La ficha entra en aux
    contNum = 0;                //Evaluamos si es un comando de colocar ficha válido

    //Hallamos los valores de la ficha
    for (int l = 0; l < strlen(aux); l++) {
        if (isdigit(aux[l])) {
            if(contNum < 2){
                // "- '0'" sirve para pasar de char a int el contenido de aux
                valorFicha[contNum] = (aux[l]) - '0';
            }
            contNum++;
        }
    }
    if(contNum != 2){   //Si el comando no lleva exactamente 2 valores numéricos
        return false;
    }

    extremo = strtok(NULL, " ,");   //El extremo entra en aux

    //Si el valor del extremo no es válido
    if ((strcmp( extremo, "derecha\n") != 0 ) && (strcmp( extremo, "izquierda\n") != 0 ))
    {
        return false;
    }

    auxFicha.left = valorFicha[0];
    auxFicha.right = valorFicha[1];

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20e1(%rip), %rsi      # 0x1299a
callq 0x33c0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x20cd(%rip), %rsi      # 0x1299a
callq 0x33c0
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3140
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1094c
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3230
cmpl $0x0, %eax
je 0x1093f
cmpl $0x2, -0x24(%rbp)
jge 0x10936
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movb %al, %cl
movslq -0x24(%rbp), %rax
movb %cl, -0x26(%rbp,%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10941
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x108e4
cmpl $0x2, -0x24(%rbp)
je 0x10958
movb $0x0, -0x1(%rbp)
jmp 0x109c1
xorl %eax, %eax
movl %eax, %edi
leaq 0x2037(%rip), %rsi      # 0x1299a
callq 0x33c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x201d(%rip), %rsi      # 0x1299d
callq 0x3390
cmpl $0x0, %eax
je 0x109a8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x200e(%rip), %rsi      # 0x129a6
callq 0x3390
cmpl $0x0, %eax
je 0x109a8
movb $0x0, -0x1(%rbp)
jmp 0x109c1
movsbl -0x26(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsbl -0x25(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/funcionesServer.cc
// Function: puttingpieceP1(domino&, ficha&, char*)
bool puttingpieceP1(domino& game, ficha &auxFicha, char* extremo)
{
    if (strcmp( extremo, "izquierda\n") == 0)
    {
        //Si la ficha se puede coloca, se coloca y se le quita de la mano
        if (game.putInBoardLeft(auxFicha)) {
            game.quitPieceJ1(auxFicha);
        }
        else{
            return false;
        }
    }

    else if (strcmp( extremo, "derecha\n") == 0)
    {
        //Si la ficha se puede coloca, se coloca y se le quita de la mano
        if (game.putInBoardRight(auxFicha)) {
            game.quitPieceJ1(auxFicha);
        }
        else{
            return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1fb7(%rip), %rsi      # 0x129a6
callq 0x3390
cmpl $0x0, %eax
jne 0x10a39
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x10cf0
testb $0x1, %al
jne 0x10a17
jmp 0x10a31
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0xa460
jmp 0x10a37
movb $0x0, -0x1(%rbp)
jmp 0x10a94
jmp 0x10a90
movq -0x20(%rbp), %rdi
leaq 0x1f59(%rip), %rsi      # 0x1299d
callq 0x3390
cmpl $0x0, %eax
jne 0x10a8e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x10dd0
testb $0x1, %al
jne 0x10a6c
jmp 0x10a86
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0xa460
jmp 0x10a8c
movb $0x0, -0x1(%rbp)
jmp 0x10a94
jmp 0x10a8e
jmp 0x10a90
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::putInBoardLeft(ficha)
bool putInBoardLeft(ficha f)
	{
		//Estructura ficha auxiliar para "girar" la ficha
		ficha aux;
		bool inserted = false;

		/*No hace falta considerar el caso con tablero vacio, ya que nunca se
		  va a llamar a esta funcion en esa situacion.*/

		//Se comprueba si la ficha se puede colocar en el extremo inicial.
		if((first == f.left) or (first == f.right))
		{
			if( f.left == first )
			{
				setFirst(f.right);
				aux.left = f.right;
				aux.right = f.left;
				board.insert(board.begin(), aux);
			}

			else
			{
				setFirst(f.left);
				board.insert(board.begin(), f);
			}

			inserted = true;
		}

		//Si no, se devuelve false (valor inicial de inserted)
		return inserted;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
movl 0x130(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x10d2a
movq -0x58(%rbp), %rax
movl 0x130(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x10dc1
movq -0x58(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x130(%rcx), %eax
jne 0x10d82
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xa9f0
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x8e60
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x97e0
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xaa30
movq %rax, -0x38(%rbp)
jmp 0x10dbd
movq -0x58(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xa9f0
movq -0x58(%rbp), %rdi
callq 0x8e60
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x97e0
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x8(%rbp), %rdx
callq 0xaa30
movq %rax, -0x50(%rbp)
movb $0x1, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::putInBoardRight(ficha)
bool putInBoardRight(ficha f)
	{
		//Estructura ficha auxiliar para "girar" la ficha
		ficha aux;
		bool inserted = false;

		/*No hace falta considerar el caso con tablero vacio, ya que nunca se
		  va a llamar a esta funcion en esa situacion.*/

		  //Se comprueba si la ficha se puede colocar en el extremo final.
  		if((last == f.left) or (last == f.right))
  		{
  			if( f.left == last )
  			{
  				setLast(f.right);
  				board.push_back(f);
  			}

  			else
  			{
  				setLast(f.left);
  				aux.left = f.right;
  				aux.right = f.left;
  				board.push_back(aux);
  			}

  			inserted = true;
  		}

		//Si no, se devuelve false (valor inicial de inserted)
		return inserted;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movl 0x134(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x10e06
movq -0x28(%rbp), %rax
movl 0x134(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x10e59
movq -0x28(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x134(%rcx), %eax
jne 0x10e30
movq -0x28(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xaa10
movq -0x28(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x96e0
jmp 0x10e55
movq -0x28(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xaa10
movq -0x28(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x96e0
movb $0x1, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: updateInterfaceUI()
void updateInterfaceUI()
{
	interfaceHeader->Print();
	for (size_t i = 0; i < interfaces.size(); ++i)
	{
		interfaces[i]->Print();
	}
	footer->Print();
	refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1a101(%rip), %rdi     # 0x1e350
callq 0x12230
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1a105(%rip), %rdi     # 0x1e370
callq 0x9c70
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x42a2
movq -0x8(%rbp), %rsi
leaq 0x1a0e9(%rip), %rdi     # 0x1e370
callq 0x9c90
movq (%rax), %rdi
callq 0x12cb0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x425c
movq 0x1a0df(%rip), %rdi     # 0x1e388
callq 0x147d0
callq 0x35a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: translateInterfaceIndex(int)
int translateInterfaceIndex(int index)
{
	int matchIndex = -1;
	for (size_t i = 0; i < interfaces.size(); ++i)
	{
		if (!interfaces[i]->IsHidden())
		{
			matchIndex++;
		}
		if (matchIndex == index)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x19917(%rip), %rdi     # 0x1e370
callq 0x9c70
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x4ab0
movq -0x18(%rbp), %rsi
leaq 0x198fb(%rip), %rdi     # 0x1e370
callq 0x9c90
movq (%rax), %rdi
callq 0x130c0
testb $0x1, %al
jne 0x4a8f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x4aa0
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x4ab7
jmp 0x4aa2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4a4a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: updateGraphs()
void updateGraphs()
{
	switch (gm)
	{
		case GM_ONE:
		{
			graphs[0]->Update();
			break;
		}
		case GM_TWO_WIDE:
		case GM_TWO_TALL:
		{
			graphs[0]->Update();
			graphs[1]->Update();
			break;
		}
		case GM_FOUR_WIDE:
		case GM_FOUR_TALL:
		case GM_TWO_WIDE_TWO_TALL:
		{
			graphs[0]->Update();
			graphs[1]->Update();
			graphs[2]->Update();
			graphs[3]->Update();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x17b92(%rip), %eax     # 0x1e3c0
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0x6853
jmp 0x6837
movl -0x4(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x6870
jmp 0x6843
movl -0x4(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x68a3
jmp 0x6906
leaq 0x17b4e(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xeee0
jmp 0x6906
leaq 0x17b31(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xeee0
leaq 0x17b19(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xeee0
jmp 0x6906
leaq 0x17afe(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xeee0
leaq 0x17ae6(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xeee0
leaq 0x17acd(%rip), %rdi     # 0x1e3a8
movl $0x2, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xeee0
leaq 0x17ab4(%rip), %rdi     # 0x1e3a8
movl $0x3, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xeee0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: deactivateGraphs()
void deactivateGraphs()
{
	switch (gm)
	{
		case GM_ONE:
		{
			graphs[0]->setActive(false);
			break;
		}
		case GM_TWO_WIDE:
		case GM_TWO_TALL:
		{
			graphs[0]->setActive(false);
			graphs[1]->setActive(false);
			break;
		}
		case GM_FOUR_WIDE:
		case GM_FOUR_TALL:
		case GM_TWO_WIDE_TWO_TALL:
		{
			graphs[0]->setActive(false);
			graphs[1]->setActive(false);
			graphs[2]->setActive(false);
			graphs[3]->setActive(false);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x17aa2(%rip), %eax     # 0x1e3c0
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0x6943
jmp 0x6927
movl -0x4(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x6962
jmp 0x6933
movl -0x4(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x6999
jmp 0x6a04
leaq 0x17a5e(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
xorl %esi, %esi
callq 0xf240
jmp 0x6a04
leaq 0x17a3f(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
xorl %esi, %esi
callq 0xf240
leaq 0x17a25(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
xorl %esi, %esi
callq 0xf240
jmp 0x6a04
leaq 0x17a08(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
xorl %esi, %esi
callq 0xf240
leaq 0x179ee(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
xorl %esi, %esi
callq 0xf240
leaq 0x179d3(%rip), %rdi     # 0x1e3a8
movl $0x2, %esi
callq 0x9f60
movq (%rax), %rdi
xorl %esi, %esi
callq 0xf240
leaq 0x179b8(%rip), %rdi     # 0x1e3a8
movl $0x3, %esi
callq 0x9f60
movq (%rax), %rdi
xorl %esi, %esi
callq 0xf240
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: printGraphs()
void printGraphs()
{
	switch (gm)
	{
		case GM_ONE:
		{
			graphs[0]->Print();
			break;
		}
		case GM_TWO_WIDE:
		case GM_TWO_TALL:
		{
			graphs[0]->Print();
			graphs[1]->Print();
			break;
		}
		case GM_FOUR_WIDE:
		case GM_FOUR_TALL:
		case GM_TWO_WIDE_TWO_TALL:
		{
			graphs[0]->Print();
			graphs[1]->Print();
			graphs[2]->Print();
			graphs[3]->Print();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x179a2(%rip), %eax     # 0x1e3c0
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0x6a43
jmp 0x6a27
movl -0x4(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x6a60
jmp 0x6a33
movl -0x4(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x6a93
jmp 0x6af6
leaq 0x1795e(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xef60
jmp 0x6af6
leaq 0x17941(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xef60
leaq 0x17929(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xef60
jmp 0x6af6
leaq 0x1790e(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xef60
leaq 0x178f6(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xef60
leaq 0x178dd(%rip), %rdi     # 0x1e3a8
movl $0x2, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xef60
leaq 0x178c4(%rip), %rdi     # 0x1e3a8
movl $0x3, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xef60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: getGraphIndex(int)
int getGraphIndex(int activeIndex)
{
	switch (gm)
	{
		case GM_ONE:
		{
			return modulo(activeIndex, 1);
		}
		case GM_TWO_WIDE:
		case GM_TWO_TALL:
		{
			return modulo(activeIndex, 2);
		}
		case GM_FOUR_WIDE:
		case GM_FOUR_TALL:
		case GM_TWO_WIDE_TWO_TALL:
		{
			return modulo(activeIndex, 4);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl 0x178af(%rip), %eax     # 0x1e3c0
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x6b33
jmp 0x6b1a
movl -0xc(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x6b45
jmp 0x6b26
movl -0xc(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x6b57
jmp 0x6b69
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x137a0
movl %eax, -0x4(%rbp)
jmp 0x6b6b
movl -0x8(%rbp), %edi
movl $0x2, %esi
callq 0x137a0
movl %eax, -0x4(%rbp)
jmp 0x6b6b
movl -0x8(%rbp), %edi
movl $0x4, %esi
callq 0x137a0
movl %eax, -0x4(%rbp)
jmp 0x6b6b
ud2
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: updateAllGraphInterfaces(Interface*)
void updateAllGraphInterfaces(Interface * interface)
{
	switch (gm)
	{
		case GM_ONE:
		{
			graphs[0]->UpdateGraphInterface(interface);
			break;
		}
		case GM_TWO_WIDE:
		case GM_TWO_TALL:
		{
			graphs[0]->UpdateGraphInterface(interface);
			graphs[1]->UpdateGraphInterface(interface);
			break;
		}
		case GM_FOUR_WIDE:
		case GM_FOUR_TALL:
		case GM_TWO_WIDE_TWO_TALL:
		{
			graphs[0]->UpdateGraphInterface(interface);
			graphs[1]->UpdateGraphInterface(interface);
			graphs[2]->UpdateGraphInterface(interface);
			graphs[3]->UpdateGraphInterface(interface);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x1782e(%rip), %eax     # 0x1e3c0
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x6bb7
jmp 0x6b9b
movl -0xc(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x6bd8
jmp 0x6ba7
movl -0xc(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x6c13
jmp 0x6c86
leaq 0x177ea(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xf1a0
jmp 0x6c86
leaq 0x177c9(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xf1a0
leaq 0x177ad(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xf1a0
jmp 0x6c86
leaq 0x1778e(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xf1a0
leaq 0x17772(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xf1a0
leaq 0x17755(%rip), %rdi     # 0x1e3a8
movl $0x2, %esi
callq 0x9f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xf1a0
leaq 0x17738(%rip), %rdi     # 0x1e3a8
movl $0x3, %esi
callq 0x9f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xf1a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Stygain[P]bandwidth-monitor/src/main.cpp
// Function: clearGraphs()
void clearGraphs()
{
	switch (gm)
	{
		case GM_ONE:
		{
			graphs[0]->Clear();
			break;
		}
		case GM_TWO_WIDE:
		case GM_TWO_TALL:
		{
			graphs[0]->Clear();
			graphs[1]->Clear();
			break;
		}
		case GM_FOUR_WIDE:
		case GM_FOUR_TALL:
		case GM_TWO_WIDE_TWO_TALL:
		{
			graphs[0]->Clear();
			graphs[1]->Clear();
			graphs[2]->Clear();
			graphs[3]->Clear();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x17722(%rip), %eax     # 0x1e3c0
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0x6cc3
jmp 0x6ca7
movl -0x4(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x6ce0
jmp 0x6cb3
movl -0x4(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x6d13
jmp 0x6d76
leaq 0x176de(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xf0b0
jmp 0x6d76
leaq 0x176c1(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xf0b0
leaq 0x176a9(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xf0b0
jmp 0x6d76
leaq 0x1768e(%rip), %rdi     # 0x1e3a8
xorl %eax, %eax
movl %eax, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xf0b0
leaq 0x17676(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xf0b0
leaq 0x1765d(%rip), %rdi     # 0x1e3a8
movl $0x2, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xf0b0
leaq 0x17644(%rip), %rdi     # 0x1e3a8
movl $0x3, %esi
callq 0x9f60
movq (%rax), %rdi
callq 0xf0b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphRow::GraphRow(int, int, int, int, int, int)
GraphRow::GraphRow(int height, int width, int placementX, int placementY, int value, int max)
{
	this->max = max;
	this->value = value;
	this->placementY = placementY;
	this->placementX = placementX;
	this->height = height;
	this->width = width;
	this->win = newwin(this->height, this->width, this->placementY, this->placementX);

	wrefresh(this->win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl 0x18(%rax), %edi
movl 0x1c(%rax), %esi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
callq 0x3340
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x3390
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphRow::Update(std::vector<GraphDataColumn*, std::allocator<GraphDataColumn*>>*, int)
void GraphRow::Update(std::vector<GraphDataColumn *> *gDataCols, int max)
{
	werase(this->win);
	float currPos = (float)this->value / (float)this->max;
	for (size_t i = 0; i < gDataCols->size(); i++)
	{
		float valuePercent = (float)gDataCols->at(i)->GetValue() / (float)max;
		float split = (float)1 / (float)this->max;
		if (valuePercent > currPos && valuePercent <= (currPos + split))
		{
			mvwprintw(this->win, 0, i, ".");
		}
		else if (valuePercent > currPos)
		{
			mvwprintw(this->win, 0, i, "|");
		}
		else if (valuePercent == 0 && currPos == 0)
		{
			mvwprintw(this->win, 0, i, "_");
		}
	}

	wrefresh(this->win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rdi
callq 0x3060
movq -0x30(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
cvtsi2ssl 0xc(%rax), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf370
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xe200
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf390
movq (%rax), %rdi
callq 0xdf90
movl %eax, %ecx
movq -0x30(%rbp), %rax
cvtsi2ss %ecx, %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
cvtsi2ssl 0xc(%rax), %xmm1
movss 0x836f(%rip), %xmm0     # 0x164ac
divss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0xe184
movss -0x24(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
addss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0xe184
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
xorl %esi, %esi
leaq 0x8335(%rip), %rcx      # 0x164b0
movb $0x0, %al
callq 0x30d0
jmp 0xe1ed
movss -0x24(%rbp), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0xe1ae
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
xorl %esi, %esi
leaq 0x830d(%rip), %rcx      # 0x164b2
movb $0x0, %al
callq 0x30d0
jmp 0xe1eb
movss -0x24(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe1e9
jp 0xe1e9
movss -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe1e9
jp 0xe1e9
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
xorl %esi, %esi
leaq 0x82d2(%rip), %rcx      # 0x164b4
movb $0x0, %al
callq 0x30d0
jmp 0xe1eb
jmp 0xe1ed
jmp 0xe1ef
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe0e2
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x3390
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphTitle::Create(int, int, int, int)
void GraphTitle::Create(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

	this->win = newwin(this->height, this->width, this->placementY, this->placementX);

	this->Update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl 0x14(%rax), %edi
movl 0x10(%rax), %esi
movl 0xc(%rax), %edx
movl 0x8(%rax), %ecx
callq 0x3340
movq -0x20(%rbp), %rdi
movq %rax, (%rdi)
callq 0xe2b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphTitle::Update()
void GraphTitle::Update()
{
	werase(this->win);

	char graphTypeString[graphTypeStringSize];
	getGraphTypeString(this->graphType, graphTypeString);

	if (this->active)
	{
		wattron(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
	}
	if (this->interface == NULL)
	{
		wprintw(this->win, "%s", graphTypeString);
	}
	else
	{
		wprintw(this->win, "%s through %s", graphTypeString, interface->name);
	}
	if (this->active)
	{
		wattroff(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
	}

	wrefresh(this->win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
callq 0x3060
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edi
leaq -0x20(%rbp), %rsi
callq 0x136f0
movq -0x28(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0xe2fb
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x31a0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xe321
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq -0x20(%rbp), %rdx
leaq 0x8389(%rip), %rsi      # 0x166a1
movb $0x0, %al
callq 0x3070
jmp 0xe341
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq -0x20(%rbp), %rdx
movq 0x20(%rax), %rax
movq (%rax), %rcx
leaq 0x817c(%rip), %rsi      # 0x164b6
movb $0x0, %al
callq 0x3070
movq -0x28(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0xe360
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x3420
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3390
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphTitle::Resize(int, int, int, int)
void GraphTitle::Resize(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

	wresize(this->win, this->height, this->width);
	mvwin(this->win, this->placementY, this->placementX);

	this->Update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq (%rax), %rdi
movl 0x14(%rax), %esi
movl 0x10(%rax), %edx
callq 0x3220
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0xc(%rax), %esi
movl 0x8(%rax), %edx
callq 0x3170
movq -0x20(%rbp), %rdi
callq 0xe2b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphMaxItem::Create(int, int, int, int)
void GraphMaxItem::Create(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

	this->win = newwin(this->height, this->width, this->placementY + 1, this->placementX);

	wrefresh(this->win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl 0x14(%rax), %edi
movl 0x10(%rax), %esi
movl 0xc(%rax), %edx
addl $0x1, %edx
movl 0x8(%rax), %ecx
callq 0x3340
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x3390
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::Graph(GraphType, std::vector<Interface*, std::allocator<Interface*>>*)
Graph::Graph(GraphType graphType, std::vector<Interface *> *interfaces)
{
	this->graphType = graphType;
	this->interfaces = interfaces;

	this->graphTitle = new GraphTitle(this->graphType, NULL);
	this->graphMaxItem = new GraphMaxItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, 0x28(%rdi)
addq $0x48, %rdi
movq %rdi, -0x48(%rbp)
callq 0xf3d0
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x40(%rbp)
callq 0xf3f0
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x30, %edi
callq 0x3320
movq %rax, -0x30(%rbp)
jmp 0xe663
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x30(%rax), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xe220
jmp 0xe679
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x20, %edi
callq 0x3320
movq %rax, -0x50(%rbp)
jmp 0xe695
movq -0x50(%rbp), %rdi
callq 0xe480
jmp 0xe6a0
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x40(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe6f6
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x3330
jmp 0xe6f6
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x3330
movq -0x40(%rbp), %rdi
callq 0xf410
movq -0x48(%rbp), %rdi
callq 0xf470
movq -0x20(%rbp), %rdi
callq 0x35c0
nopw %cs:(%rax,%rax)
// File: Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::~Graph()
Graph::~Graph()
{
	gDataCols.clear();
	gRows.clear();
	delete this->graphTitle;
	delete this->graphMaxItem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x60, %rdi
callq 0xf4d0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0xf4f0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xe76a
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0x3330
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe78a
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x3330
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0xf410
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0xf470
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)