LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::check_repeat_msg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char)
bool check_repeat_msg(const string &s, const unsigned char cp)
{
	if(bottom_idx && s == msgbuffer[bottom_idx-1].text
		&& cp == msgbuffer[bottom_idx-1].cpair)
	{
		if(msgbuffer[bottom_idx-1].repeat != '+' - '1' // this value is -1
			&& ++(msgbuffer[bottom_idx-1].repeat) > 8)
			msgbuffer[bottom_idx-1].repeat = '+' - '1';
		redraw_msgs();
		last_move.update(); /* only update this! Then the next 
			message can be printed without unnecessary delay */
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpb $0x0, 0x1aeaf(%rip)     # 0x29178
je 0xe3b9
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl 0x1ae9a(%rip), %eax     # 0x29178
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x1ad6d(%rip), %rdi     # 0x29058
callq 0xe5c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xde70
testb $0x1, %al
jne 0xe305
jmp 0xe3b9
movzbl -0x11(%rbp), %eax
movl %eax, -0x24(%rbp)
movsbl 0x1ae65(%rip), %eax     # 0x29178
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x1ad38(%rip), %rdi     # 0x29058
callq 0xe5c0
movq %rax, %rcx
movl -0x24(%rbp), %eax
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jne 0xe3b9
movsbl 0x1ae3a(%rip), %eax     # 0x29178
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x1ad0d(%rip), %rdi     # 0x29058
callq 0xe5c0
movsbl 0x21(%rax), %eax
cmpl $-0x6, %eax
je 0xe3a2
movsbl 0x1ae18(%rip), %eax     # 0x29178
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x1aceb(%rip), %rdi     # 0x29058
callq 0xe5c0
movq %rax, %rcx
movb 0x21(%rcx), %al
addb $0x1, %al
movb %al, 0x21(%rcx)
movsbl %al, %eax
cmpl $0x8, %eax
jle 0xe3a2
movsbl 0x1adec(%rip), %eax     # 0x29178
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x1acbf(%rip), %rdi     # 0x29058
callq 0xe5c0
movb $-0x6, 0x21(%rax)
callq 0xe5f0
leaq 0x1ad9a(%rip), %rdi     # 0x29148
callq 0x19b60
movb $0x1, -0x1(%rbp)
jmp 0xe3bd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::move_msgs()
void move_msgs()
{
	if(bottom_idx)
	{
		msgbuffer.pop_front();
		msgbuffer.push_back(MsgBufferLine());
		--bottom_idx;
		last_move.update();
		for(char y = 0; y < bottom_idx/2; ++y)
			msgbuffer[y].dimmen();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
cmpb $0x0, 0x1ace9(%rip)     # 0x29178
je 0xe5a9
leaq 0x1abbc(%rip), %rdi     # 0x29058
callq 0xe980
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5840
movq -0x68(%rbp), %rdx
leaq 0xdfd0(%rip), %rsi      # 0x1c489
leaq -0x48(%rbp), %rdi
callq 0xa030
jmp 0xe4c4
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0xe400
jmp 0xe4d5
leaq 0x1ab7c(%rip), %rdi     # 0x29058
leaq -0x28(%rbp), %rsi
callq 0xe3d0
jmp 0xe4e7
leaq -0x28(%rbp), %rdi
callq 0xe460
leaq -0x48(%rbp), %rdi
callq 0x5968
leaq -0x49(%rbp), %rdi
callq 0x5540
movb 0x1ac70(%rip), %al      # 0x29178
addb $-0x1, %al
movb %al, 0x1ac68(%rip)      # 0x29178
leaq 0x1ac31(%rip), %rdi     # 0x29148
callq 0x19b60
movb $0x0, -0x5d(%rbp)
movsbl -0x5d(%rbp), %eax
movl %eax, -0x6c(%rbp)
movsbl 0x1ac4a(%rip), %eax     # 0x29178
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0xe5a7
movsbq -0x5d(%rbp), %rsi
leaq 0x1ab0d(%rip), %rdi     # 0x29058
callq 0xe5c0
movq %rax, %rdi
callq 0x106e0
movb -0x5d(%rbp), %al
addb $0x1, %al
movb %al, -0x5d(%rbp)
jmp 0xe520
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xe59c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xe593
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe460
leaq -0x48(%rbp), %rdi
callq 0x5968
leaq -0x49(%rbp), %rdi
callq 0x5540
jmp 0xe5af
jmp 0xe5a9
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5830
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::redraw_msgs()
void redraw_msgs()
{
	string tmp_str;
	for(char y = 0; y < MSG_WIN_Y-1; ++y)
	{
		if(msgbuffer[y].repeat)
		{
			tmp_str = msgbuffer[y].text;
			if(num_syms(tmp_str) > MSG_WIN_X-4) // 4: len(" [?]")
				del_syms(tmp_str, MSG_WIN_X-4);
			tmp_str += " [";
			tmp_str += char(msgbuffer[y].repeat + '1');
			tmp_str += ']';
			Base::print_str(tmp_str.c_str(), msgbuffer[y].cpair,
				0, y, MSG_WIN, true);
		}
		else
			Base::print_str(msgbuffer[y].text.c_str(), msgbuffer[y].cpair,
				0, y, MSG_WIN, true);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x20(%rbp), %rdi
callq 0x56f0
movb $0x0, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0xe, %eax
jge 0xe77b
movsbq -0x21(%rbp), %rsi
leaq 0x1aa3a(%rip), %rdi     # 0x29058
callq 0xe5c0
cmpb $0x0, 0x21(%rax)
je 0xe71a
movsbq -0x21(%rbp), %rsi
leaq 0x1aa1f(%rip), %rdi     # 0x29058
callq 0xe5c0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x5060
jmp 0xe64c
leaq -0x20(%rbp), %rdi
callq 0x1a800
movw %ax, -0x36(%rbp)
jmp 0xe65b
movw -0x36(%rbp), %ax
cwtl
cmpl $0x35, %eax
jle 0xe691
leaq -0x20(%rbp), %rdi
movl $0x35, %esi
callq 0x1a970
jmp 0xe675
jmp 0xe691
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5968
jmp 0xe78a
leaq 0xdf93(%rip), %rsi      # 0x1c62b
leaq -0x20(%rbp), %rdi
callq 0x5480
jmp 0xe6a3
movsbq -0x21(%rbp), %rsi
leaq 0x1a9a9(%rip), %rdi     # 0x29058
callq 0xe5c0
movzbl 0x21(%rax), %eax
addl $0x31, %eax
movsbl %al, %esi
leaq -0x20(%rbp), %rdi
callq 0x52f0
jmp 0xe6c9
leaq -0x20(%rbp), %rdi
movl $0x5d, %esi
callq 0x52f0
jmp 0xe6d9
leaq -0x20(%rbp), %rdi
callq 0x5200
movq %rax, -0x40(%rbp)
movsbq -0x21(%rbp), %rsi
leaq 0x1a966(%rip), %rdi     # 0x29058
callq 0xe5c0
movq -0x40(%rbp), %rdi
movzbl 0x20(%rax), %esi
movsbl -0x21(%rbp), %ecx
xorl %edx, %edx
movl $0x2, %r8d
movl $0x1, %r9d
callq 0x9480
jmp 0xe718
jmp 0xe76c
movsbq -0x21(%rbp), %rsi
leaq 0x1a932(%rip), %rdi     # 0x29058
movq %rdi, -0x50(%rbp)
callq 0xe5c0
movq %rax, %rdi
callq 0x5200
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
movsbq -0x21(%rbp), %rsi
callq 0xe5c0
movq -0x48(%rbp), %rdi
movzbl 0x20(%rax), %esi
movsbl -0x21(%rbp), %ecx
xorl %edx, %edx
movl $0x2, %r8d
movl $0x1, %r9d
callq 0x9480
jmp 0xe76a
jmp 0xe76c
jmp 0xe76e
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0xe605
leaq -0x20(%rbp), %rdi
callq 0x5968
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5830
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: upd_msgs()
void upd_msgs()
{
	// add messages in avail, if any:
	if(!msgavail.empty() && reference.update() - last_add >= STAY_TIME)
	{
		if(check_repeat_msg(msgavail.front().text, msgavail.front().cpair))
			msgavail.pop_front();
		else
		{
			move_msgs();
			msgbuffer[bottom_idx] = msgavail.front();
			msgavail.pop_front();
			++bottom_idx;
			last_add.update();
			redraw_msgs();
		}
	}
	else if(reference.update() - last_move >= MOVE_FREQ)
	{
		move_msgs();
		redraw_msgs();
	}

	// clock check:
	if(reference.update() - last_second >= 1000)
	{
		if(maptime)
			--maptime;
		if(spawntime)
			--spawntime;
		redraw_clocks();
		last_second.update();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1a8f9(%rip), %rdi     # 0x290a8
callq 0xe920
testb $0x1, %al
jne 0xe881
leaq 0x1a9bd(%rip), %rdi     # 0x29180
callq 0x19b60
movq %rax, %rdi
leaq 0x1a986(%rip), %rsi     # 0x29158
callq 0x19b90
cmpl $0x2ee, %eax            # imm = 0x2EE
jb 0xe881
leaq 0x1a8bf(%rip), %rdi     # 0x290a8
callq 0xe950
movq %rax, -0x8(%rbp)
leaq 0x1a8af(%rip), %rdi     # 0x290a8
callq 0xe950
movq -0x8(%rbp), %rdi
movzbl 0x20(%rax), %esi
callq 0xe2b0
testb $0x1, %al
jne 0xe811
jmp 0xe81f
leaq 0x1a890(%rip), %rdi     # 0x290a8
callq 0xe980
jmp 0xe87f
callq 0xe480
leaq 0x1a87d(%rip), %rdi     # 0x290a8
callq 0xe950
movq %rax, -0x10(%rbp)
movsbq 0x1a93c(%rip), %rsi     # 0x29178
leaq 0x1a815(%rip), %rdi     # 0x29058
callq 0xe5c0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0xe9f0
leaq 0x1a84d(%rip), %rdi     # 0x290a8
callq 0xe980
movb 0x1a912(%rip), %al      # 0x29178
addb $0x1, %al
movb %al, 0x1a90a(%rip)      # 0x29178
leaq 0x1a8e3(%rip), %rdi     # 0x29158
callq 0x19b60
callq 0xe5f0
jmp 0xe8af
leaq 0x1a8f8(%rip), %rdi     # 0x29180
callq 0x19b60
movq %rax, %rdi
leaq 0x1a8b1(%rip), %rsi     # 0x29148
callq 0x19b90
cmpl $0xdac, %eax            # imm = 0xDAC
jb 0xe8ad
callq 0xe480
callq 0xe5f0
jmp 0xe8af
leaq 0x1a8ca(%rip), %rdi     # 0x29180
callq 0x19b60
movq %rax, %rdi
leaq 0x1a8a3(%rip), %rsi     # 0x29168
callq 0x19b90
cmpl $0x3e8, %eax            # imm = 0x3E8
jb 0xe915
cmpw $0x0, 0x1a8b7(%rip)     # 0x29190
je 0xe8ed
movw 0x1a8ae(%rip), %ax      # 0x29190
addw $-0x1, %ax
movw %ax, 0x1a8a3(%rip)      # 0x29190
cmpb $0x0, 0x1a89e(%rip)     # 0x29192
je 0xe904
movb 0x1a896(%rip), %al      # 0x29192
addb $-0x1, %al
movb %al, 0x1a88e(%rip)      # 0x29192
callq 0xea30
leaq 0x1a858(%rip), %rdi     # 0x29168
callq 0x19b60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::redraw_chat()
void redraw_chat()
{
	char num = min(int(Base::num_chat_lines_to_show()), int(num_chat_lines - chat_top));
	for(char i = 0; i < num; ++i)
	{
		Base::incr_print_start(0, i, CHAT_WIN);
		Base::incr_print(chatbuffer[chat_top+i].speaker.c_str(), 3, CHAT_WIN);
		Base::incr_print(team_ind[chatbuffer[chat_top+i].team],
			team_colour[chatbuffer[chat_top+i].team], CHAT_WIN);
		Base::incr_print(chatbuffer[chat_top+i].text.c_str(), 7, CHAT_WIN);
		Base::incr_print_end(CHAT_WIN, true);
	}
	// if necessary, print indicators of there being more messages:
	if(chat_top)
		Base::less_chat_ind();
	if(chat_top + num < num_chat_lines)
		Base::more_chat_ind();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x98e0
movzbl %al, %eax
movl %eax, -0x8(%rbp)
movswl 0x19dea(%rip), %eax     # 0x29194
movswl 0x19de5(%rip), %ecx     # 0x29196
subl %ecx, %eax
movl %eax, -0xc(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xd4b0
movl (%rax), %eax
movb %al, -0x1(%rbp)
movb $0x0, -0xd(%rbp)
movsbl -0xd(%rbp), %eax
movsbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jge 0xf4e1
xorl %edi, %edi
movl $0x1, %edx
movsbl -0xd(%rbp), %esi
callq 0x9700
movswl 0x19da3(%rip), %eax     # 0x29196
movsbl -0xd(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
leaq 0x19cf5(%rip), %rdi     # 0x290f8
callq 0x10760
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5200
movq %rax, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x9740
movswl 0x19d69(%rip), %eax     # 0x29196
movsbl -0xd(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
leaq 0x19cbb(%rip), %rdi     # 0x290f8
callq 0x10760
movzbl 0x40(%rax), %eax
movl %eax, %ecx
leaq 0x190b1(%rip), %rax     # 0x28500
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movswl 0x19d38(%rip), %eax     # 0x29196
movsbl -0xd(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
leaq 0x19c8a(%rip), %rdi     # 0x290f8
callq 0x10760
movq -0x18(%rbp), %rdi
movzbl 0x40(%rax), %eax
movl %eax, %ecx
movl $0x1, %edx
leaq 0xd1da(%rip), %rax      # 0x1c663
movzbl (%rax,%rcx), %esi
callq 0x9740
movswl 0x19cfd(%rip), %eax     # 0x29196
movsbl -0xd(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
leaq 0x19c4f(%rip), %rdi     # 0x290f8
callq 0x10760
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
movl $0x7, %esi
movl $0x1, %edx
callq 0x9740
movl $0x1, %esi
movl %esi, %edi
callq 0x97a0
movb -0xd(%rbp), %al
addb $0x1, %al
movb %al, -0xd(%rbp)
jmp 0xf3cc
cmpw $0x0, 0x19cad(%rip)     # 0x29196
je 0xf4f0
callq 0x9870
movswl 0x19c9f(%rip), %eax     # 0x29196
movsbl -0x1(%rbp), %ecx
addl %ecx, %eax
movswl 0x19c90(%rip), %ecx     # 0x29194
cmpl %ecx, %eax
jge 0xf50d
callq 0x9800
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: clocksync(unsigned short, unsigned char)
void clocksync(const unsigned short t, const unsigned char spawn)
{
	maptime = t;
	spawntime = spawn;
	redraw_clocks();
	last_second.update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, -0x2(%rbp)
movb %al, -0x3(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x19bd0(%rip)      # 0x29190
movb -0x3(%rbp), %al
movb %al, 0x19bc9(%rip)      # 0x29192
callq 0xea30
leaq 0x19b93(%rip), %rdi     # 0x29168
callq 0x19b60
addq $0x10, %rsp
popq %rbp
retq
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::MsgBufferLine::dimmen()
void dimmen() // adjust colour "dimmer"
	{
		if(cpair == 8 || cpair == 0) // already at the dimmest
			return;
		if(cpair > 8 && cpair < BASE_COLOURS)
			cpair -= 8;
		else if(cpair >= C_TREE_LIT)
			cpair -= NUM_NORM_COLS;
		else
			cpair = 8;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movzbl 0x20(%rax), %eax
cmpl $0x8, %eax
je 0x10706
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0x10708
jmp 0x10759
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x8, %eax
jle 0x10732
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x10, %eax
jge 0x10732
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
subl $0x8, %ecx
movb %cl, 0x20(%rax)
jmp 0x10759
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x2b, %eax
jl 0x1074f
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
subl $0x14, %ecx
movb %cl, 0x20(%rax)
jmp 0x10757
movq -0x10(%rbp), %rax
movb $0x8, 0x20(%rax)
jmp 0x10759
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/network.cpp
// Function: (anonymous namespace)::add_id_info_for_server(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void add_id_info_for_server(const string &serverip)
{
	cur_id = 0xFFFF;
	ifstream file((Config::configdir() + serversfile_name).c_str());
	string ipstr, passw;
	unsigned short sh;
	while(file)
	{
		// NOTE: not very error tolerant; users should not mess with the file
		file >> ipstr;
		file >> sh;
		file >> passw;
		if(ipstr == serverip) // match
		{
			cur_id = sh;
			break;
		}
	}
	send_buffer.add(cur_id);
	if(cur_id != 0xFFFF) // some ID was found
		send_buffer.add(passw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movw $0xffff, 0x16e70(%rip)  # imm = 0xFFFF
callq 0x161d0
movq %rax, %rsi
leaq 0x16d91(%rip), %rdx     # 0x2a2e8
leaq -0x230(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x14680
movq -0x290(%rbp), %rdi
callq 0x5200
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x5880
jmp 0x1358c
leaq -0x230(%rbp), %rdi
callq 0x5968
leaq -0x260(%rbp), %rdi
callq 0x56f0
leaq -0x280(%rbp), %rdi
callq 0x56f0
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x5640
movb %al, -0x291(%rbp)
jmp 0x135d0
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x135df
jmp 0x136a4
leaq -0x210(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x5650
jmp 0x135f4
leaq -0x210(%rbp), %rdi
leaq -0x282(%rbp), %rsi
callq 0x52a0
jmp 0x13609
leaq -0x210(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x5650
jmp 0x1361e
movq -0x8(%rbp), %rsi
leaq -0x260(%rbp), %rdi
callq 0xde70
testb $0x1, %al
jne 0x13634
jmp 0x1369f
movw -0x282(%rbp), %ax
movw %ax, 0x16d76(%rip)      # 0x2a3b8
jmp 0x136a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x5968
jmp 0x1370b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x5968
leaq -0x260(%rbp), %rdi
callq 0x5968
leaq -0x210(%rbp), %rdi
callq 0x5150
jmp 0x1370b
jmp 0x135b0
movzwl 0x16d0d(%rip), %esi     # 0x2a3b8
leaq 0x16426(%rip), %rdi     # 0x29ad8
callq 0x19cd0
jmp 0x136b9
movzwl 0x16cf8(%rip), %eax     # 0x2a3b8
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x136de
leaq 0x1640a(%rip), %rdi     # 0x29ad8
leaq -0x280(%rbp), %rsi
callq 0x19d40
jmp 0x136dc
jmp 0x136de
leaq -0x280(%rbp), %rdi
callq 0x5968
leaq -0x260(%rbp), %rdi
callq 0x5968
leaq -0x210(%rbp), %rdi
callq 0x5150
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x5830
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::disconnect()
void Network::disconnect()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_QUIT);
	send_buffer.add(cur_id);
	do_send();
	freeaddrinfo(servinfo);
	close(s_me);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x15e5d(%rip), %rdi     # 0x29ad8
callq 0x19c70
leaq 0x15e51(%rip), %rdi     # 0x29ad8
movl $0x2, %esi
callq 0x19c90
leaq 0x15e40(%rip), %rdi     # 0x29ad8
movzwl 0x16719(%rip), %esi     # 0x2a3b8
callq 0x19cd0
callq 0x13720
movq 0x166e0(%rip), %rdi     # 0x2a390
callq 0x56a0
movl 0x166e5(%rip), %edi     # 0x2a3a0
callq 0x5900
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_action(unsigned char, unsigned char, unsigned char)
void Network::send_action(const unsigned char xncode, const unsigned char var1, const unsigned char var2)
{
	if(Config::act_per_turn())
	{
		if(axn_counter)
			return;
	}
	else if(reftimer.update() - last_sent_axn < 50) // every 50 ms at most?
		return;
	// If here, may send:
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_TAKE_ACTION);
	send_buffer.add(cur_id);
	send_buffer.add(curturn);
	send_buffer.add(axn_counter);
	send_buffer.add(xncode);
	if(xncode == XN_MOVE || xncode == XN_SHOOT || xncode == XN_ZAP
		|| xncode == XN_CIRCLE_ATTACK || xncode == XN_HEAL || xncode == XN_MINE)
	{
		send_buffer.add(static_cast<unsigned char>(var1));
		if(xncode == XN_SHOOT)
			send_buffer.add(static_cast<unsigned char>(var2));
	}
	do_send();
	++axn_counter;
	last_sent_axn.update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x1(%rbp)
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
callq 0x161c0
testb $0x1, %al
jne 0x14234
jmp 0x14244
cmpb $0x0, 0x16181(%rip)     # 0x2a3bc
je 0x14242
jmp 0x14351
jmp 0x1426b
leaq 0x16175(%rip), %rdi     # 0x2a3c0
callq 0x19b60
movq %rax, %rdi
leaq 0x1614e(%rip), %rsi     # 0x2a3a8
callq 0x19b90
cmpl $0x32, %eax
jae 0x14269
jmp 0x14351
jmp 0x1426b
leaq 0x15866(%rip), %rdi     # 0x29ad8
callq 0x19c70
leaq 0x1585a(%rip), %rdi     # 0x29ad8
movl $0x7, %esi
callq 0x19c90
leaq 0x15849(%rip), %rdi     # 0x29ad8
movzwl 0x16122(%rip), %esi     # 0x2a3b8
callq 0x19cd0
leaq 0x15836(%rip), %rdi     # 0x29ad8
movzwl 0x16111(%rip), %esi     # 0x2a3ba
callq 0x19cd0
leaq 0x15823(%rip), %rdi     # 0x29ad8
movzbl 0x16100(%rip), %esi     # 0x2a3bc
callq 0x19c90
leaq 0x15810(%rip), %rdi     # 0x29ad8
movzbl -0x1(%rbp), %esi
callq 0x19c90
movzbl -0x1(%rbp), %eax
cmpl $0x4, %eax
je 0x14307
movzbl -0x1(%rbp), %eax
cmpl $0x5, %eax
je 0x14307
movzbl -0x1(%rbp), %eax
cmpl $0x7, %eax
je 0x14307
movzbl -0x1(%rbp), %eax
cmpl $0xa, %eax
je 0x14307
movzbl -0x1(%rbp), %eax
cmpl $0xc, %eax
je 0x14307
movzbl -0x1(%rbp), %eax
cmpl $0xb, %eax
jne 0x14332
leaq 0x157ca(%rip), %rdi     # 0x29ad8
movzbl -0x2(%rbp), %esi
callq 0x19c90
movzbl -0x1(%rbp), %eax
cmpl $0x5, %eax
jne 0x14330
leaq 0x157b1(%rip), %rdi     # 0x29ad8
movzbl -0x3(%rbp), %esi
callq 0x19c90
jmp 0x14332
callq 0x13720
movb 0x1607f(%rip), %al      # 0x2a3bc
addb $0x1, %al
movb %al, 0x16077(%rip)      # 0x2a3bc
leaq 0x1605c(%rip), %rdi     # 0x2a3a8
callq 0x19b60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void Network::send_line(const string &s, const bool chat)
{
	send_buffer.clear();
	if(chat)
		send_buffer.add((unsigned char)MID_SAY_CHAT);
	else
		send_buffer.add((unsigned char)MID_SAY_ALOUD);
	send_buffer.add(cur_id);
	if(s.size() <= MAXIMUM_STR_LEN)	
		send_buffer.add(s);
	else
		send_buffer.add(s.substr(0, low_bound(s, MAXIMUM_STR_LEN)));
	do_send();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq 0x1575d(%rip), %rdi     # 0x29ad8
callq 0x19c70
testb $0x1, -0x9(%rbp)
je 0x14399
leaq 0x1574b(%rip), %rdi     # 0x29ad8
movl $0x4, %esi
callq 0x19c90
jmp 0x143aa
leaq 0x15738(%rip), %rdi     # 0x29ad8
movl $0x6, %esi
callq 0x19c90
leaq 0x15727(%rip), %rdi     # 0x29ad8
movzwl 0x16000(%rip), %esi     # 0x2a3b8
callq 0x19cd0
movq -0x8(%rbp), %rdi
callq 0x5350
cmpq $0x15e, %rax            # imm = 0x15E
ja 0x143e0
movq -0x8(%rbp), %rsi
leaq 0x156ff(%rip), %rdi     # 0x29ad8
callq 0x19d40
jmp 0x1443f
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x15e, %esi            # imm = 0x15E
callq 0x1aaa0
movq -0x50(%rbp), %rsi
movswq %ax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x54e0
movq -0x48(%rbp), %rsi
leaq 0x156c2(%rip), %rdi     # 0x29ad8
callq 0x19d40
jmp 0x1441d
leaq -0x30(%rbp), %rdi
callq 0x5968
jmp 0x1443f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5968
jmp 0x1444a
callq 0x13720
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5830
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_spawn(unsigned char)
void Network::send_spawn(const unsigned char newclass)
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_SPAWN_AXN);
	send_buffer.add(cur_id);
	send_buffer.add(newclass);
	do_send();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
leaq 0x15663(%rip), %rdi     # 0x29ad8
callq 0x19c70
leaq 0x15657(%rip), %rdi     # 0x29ad8
movl $0x8, %esi
callq 0x19c90
leaq 0x15646(%rip), %rdi     # 0x29ad8
movzwl 0x15f1f(%rip), %esi     # 0x2a3b8
callq 0x19cd0
leaq 0x15633(%rip), %rdi     # 0x29ad8
movzbl -0x1(%rbp), %esi
callq 0x19c90
callq 0x13720
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_switch()
void Network::send_switch()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_TEAM_SWITCH);
	send_buffer.add(cur_id);
	do_send();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1560d(%rip), %rdi     # 0x29ad8
callq 0x19c70
leaq 0x15601(%rip), %rdi     # 0x29ad8
movl $0x9, %esi
callq 0x19c90
leaq 0x155f0(%rip), %rdi     # 0x29ad8
movzwl 0x15ec9(%rip), %esi     # 0x2a3b8
callq 0x19cd0
callq 0x13720
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_teami_req()
void Network::send_teami_req()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_TEAM_INFO);
	send_buffer.add(cur_id);
	do_send();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x155cd(%rip), %rdi     # 0x29ad8
callq 0x19c70
leaq 0x155c1(%rip), %rdi     # 0x29ad8
movl $0x5, %esi
callq 0x19c90
leaq 0x155b0(%rip), %rdi     # 0x29ad8
movzwl 0x15e89(%rip), %esi     # 0x2a3b8
callq 0x19cd0
callq 0x13720
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/settings.cpp
// Function: Config::convert_key(char)
e_Key_binding Config::convert_key(const char key)
{
	string::size_type index = key_bindings.find(key);
	if(index == string::npos) // no such key mapped
		return MAX_KEY_BINDING;
	return e_Key_binding(index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
leaq 0x14683(%rip), %rdi     # 0x2a4b8
xorl %eax, %eax
movl %eax, %edx
movsbl -0x5(%rbp), %esi
callq 0x56b0
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0x15e56
movl $0x1b, -0x4(%rbp)
jmp 0x15e5d
movq -0x10(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/settings.cpp
// Function: (anonymous namespace)::fill_kph(char)
void fill_kph(const char k)
{
	if(k == '\t') // special
	{
		keyplaceholder[0] = '\\';
		keyplaceholder[1] = 't';
	}
	else if(k < 27) // means it's a ctrl key
	{
		keyplaceholder[0] = '^';
		keyplaceholder[1] = k + CTRL_ADD;
	}
	else if(k == ' ') // also special
	{
		keyplaceholder[0] = 'S';
		keyplaceholder[1] = 'P';
	}
	else
	{
		keyplaceholder[0] = k;
		keyplaceholder[1] = '\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x9, %eax
jne 0x15e93
movb $0x5c, 0x12696(%rip)    # 0x28520
movb $0x74, 0x12690(%rip)    # 0x28521
jmp 0x15edf
movsbl -0x1(%rbp), %eax
cmpl $0x1b, %eax
jge 0x15eb2
movb $0x5e, 0x1267d(%rip)    # 0x28520
movsbl -0x1(%rbp), %eax
addl $0x40, %eax
movb %al, 0x12671(%rip)      # 0x28521
jmp 0x15edd
movsbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jne 0x15ecb
movb $0x53, 0x1265e(%rip)    # 0x28520
movb $0x50, 0x12658(%rip)    # 0x28521
jmp 0x15edb
movb -0x1(%rbp), %al
movb %al, 0x1264c(%rip)      # 0x28520
movb $0x0, 0x12646(%rip)     # 0x28521
jmp 0x15edd
jmp 0x15edf
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/settings.cpp
// Function: Config::save_msg_memory()
void Config::save_msg_memory()
{
	ofstream cmfile((confdir_str + "chatmemory").c_str());
	if(stored_msgs)
	{
		if(!cmfile)
			cerr << "Warning: failed to save chat memory." << endl;
		else
		{
			while(prev_strs.size() > (unsigned int)stored_msgs)
				prev_strs.erase(prev_strs.begin());
			while(!prev_strs.empty())
			{
				cmfile << prev_strs.front() << endl;
				prev_strs.erase(prev_strs.begin());
			}
		}
	}
	// else opening the file causes it to be emptied
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
leaq 0x1479e(%rip), %rsi     # 0x2a6a0
leaq 0x6c56(%rip), %rdx      # 0x1cb5f
leaq -0x220(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x16500
movq -0x268(%rbp), %rdi
callq 0x5200
movq %rax, %rsi
leaq -0x200(%rbp), %rdi
movl $0x10, %edx
callq 0x5550
jmp 0x15f3e
leaq -0x220(%rbp), %rdi
callq 0x5968
cmpw $0x0, 0x125d2(%rip)     # 0x28524
je 0x16127
movq -0x200(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x200(%rbp,%rax), %rdi
callq 0x5250
movb %al, -0x269(%rbp)
jmp 0x15f78
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x15f84
jmp 0x16000
movq 0x1205d(%rip), %rdi     # 0x27fe8
leaq 0x6bd8(%rip), %rsi      # 0x1cb6a
callq 0x54b0
movq %rax, -0x278(%rbp)
jmp 0x15fa0
movq -0x278(%rbp), %rdi
movq 0x11ff2(%rip), %rsi     # 0x27fa0
callq 0x5510
jmp 0x15fb5
jmp 0x16125
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x5968
jmp 0x1613c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x5730
jmp 0x1613c
jmp 0x16002
leaq 0x12fdf(%rip), %rdi     # 0x28fe8
callq 0xa1b0
movswl 0x1250f(%rip), %ecx     # 0x28524
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x16075
leaq 0x12fc5(%rip), %rdi     # 0x28fe8
movq %rdi, -0x288(%rbp)
callq 0xabb0
movq %rax, -0x240(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0xd400
movq -0x288(%rbp), %rdi
movq -0x238(%rbp), %rsi
callq 0xd5a0
movq %rax, -0x280(%rbp)
jmp 0x16065
movq -0x280(%rbp), %rax
movq %rax, -0x248(%rbp)
jmp 0x16002
jmp 0x16077
leaq 0x12f6a(%rip), %rdi     # 0x28fe8
callq 0xd4f0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1608e
jmp 0x16123
leaq 0x12f53(%rip), %rdi     # 0x28fe8
callq 0x14810
movq %rax, %rsi
leaq -0x200(%rbp), %rdi
callq 0x5430
movq %rax, -0x290(%rbp)
jmp 0x160b2
movq -0x290(%rbp), %rdi
movq 0x11ee0(%rip), %rsi     # 0x27fa0
callq 0x5510
jmp 0x160c7
leaq 0x12f1a(%rip), %rdi     # 0x28fe8
movq %rdi, -0x2a0(%rbp)
callq 0xabb0
movq %rax, -0x258(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0xd400
movq -0x2a0(%rbp), %rdi
movq -0x250(%rbp), %rsi
callq 0xd5a0
movq %rax, -0x298(%rbp)
jmp 0x16110
movq -0x298(%rbp), %rax
movq %rax, -0x260(%rbp)
jmp 0x16077
jmp 0x16125
jmp 0x16127
leaq -0x200(%rbp), %rdi
callq 0x5730
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x5830
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/settings.cpp
// Function: Config::do_aliasing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Config::do_aliasing(string &s)
{
	size_t i;
	for(map<string,string>::iterator it = aliases.begin(); it != aliases.end(); ++it)
	{
		if((i = s.find(it->first)) != string::npos)
		{
			s.replace(i, it->first.size(), it->second);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1448d(%rip), %rdi     # 0x2a6c0
callq 0x16580
movq %rax, -0x18(%rbp)
leaq 0x1447d(%rip), %rdi     # 0x2a6c0
callq 0x165e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165b0
testb $0x1, %al
jne 0x16262
jmp 0x162e5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16610
movq -0x28(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5940
movq %rax, -0x10(%rbp)
cmpq $-0x1, %rax
je 0x162d5
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16610
movq %rax, %rdi
callq 0x5350
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16610
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
addq $0x20, %rcx
callq 0x51a0
jmp 0x162e5
jmp 0x162d7
leaq -0x18(%rbp), %rdi
callq 0x16630
jmp 0x1623c
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/view.cpp
// Function: (anonymous namespace)::draw_titles()
void draw_titles()
{
	char len;
	char *pos = &(viewbuffer[VIEWSIZE*VIEWSIZE*2+1]);
	char x, y;
	char syms;
	for(char num = viewbuffer[VIEWSIZE*VIEWSIZE*2]; num > 0; --num)
	{
		y = *(pos+1); // pos&pos+1 are x/y pair, string begins at pos+2.
		len = strlen(pos+2);
		// If we are alive, don't draw any title coming to the center (that
		// would be our OWN title)
		if(*pos != VIEWSIZE/2 || y != VIEWSIZE/2 || !ClassCPV::im_alive())
		{
			// x-position might need shifting so the string doesn't go over the edge:
			syms = num_syms(string(pos+2));
			x = *pos - syms/2;
			if(x < 0)
				x = 0;
			else if(x + syms > VIEWSIZE)
				x = VIEWSIZE - syms;
			Base::print_str(pos+2, TITLE_CPAIR, x, y, VIEW_WIN);
		}
		pos += len+3; // lenght of string + '\0' + 2 chars
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x11851(%rip), %rax     # 0x2a820
addq $0x423, %rax            # imm = 0x423
movq %rax, -0x10(%rbp)
movb 0x11c63(%rip), %al      # 0x2ac42
movb %al, -0x14(%rbp)
movsbl -0x14(%rbp), %eax
cmpl $0x0, %eax
jle 0x19142
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
callq 0x5230
movb %al, -0x1(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1902b
movsbl -0x12(%rbp), %eax
cmpl $0xb, %eax
jne 0x1902b
callq 0xb3f0
testb $0x1, %al
jne 0x19120
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5840
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xa030
jmp 0x19057
leaq -0x38(%rbp), %rdi
callq 0x1a800
movw %ax, -0x62(%rbp)
jmp 0x19066
movw -0x62(%rbp), %ax
movb %al, -0x13(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5968
leaq -0x39(%rbp), %rdi
callq 0x5540
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x68(%rbp)
movsbl -0x13(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x68(%rbp), %eax
subl %ecx, %eax
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jge 0x190dc
movb $0x0, -0x11(%rbp)
jmp 0x190fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x190d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5968
leaq -0x39(%rbp), %rdi
callq 0x5540
jmp 0x19148
movsbl -0x11(%rbp), %eax
movsbl -0x13(%rbp), %ecx
addl %ecx, %eax
cmpl $0x17, %eax
jle 0x190f9
movsbl -0x13(%rbp), %ecx
movl $0x17, %eax
subl %ecx, %eax
movb %al, -0x11(%rbp)
jmp 0x190fb
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movb -0x11(%rbp), %al
movl $0x6a, %esi
movl $0x3, %r8d
xorl %r9d, %r9d
movsbl %al, %edx
movsbl -0x12(%rbp), %ecx
callq 0x9480
movsbl -0x1(%rbp), %ecx
addl $0x3, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movb -0x14(%rbp), %al
addb $-0x1, %al
movb %al, -0x14(%rbp)
jmp 0x18fe2
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5830
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/view.cpp
// Function: redraw_view()
void redraw_view()
{
	if(clientstate == CS_LIMBO)
		Base::print_view(limboview);
	else if(clientstate == CS_HELP)
	{
		if(!helpshown) // first time to show help
		{
			// replace keys in the view with actual values
			char *kmv;
			short idx;
			for(e_Key_binding kb = KB_8; kb < MAX_KEY_BINDING; kb = e_Key_binding(kb+1))
			{
				kmv = Config::key_map_value(kb);
				idx = kmv_idx[kb];
				while(*kmv)
				{
					helpview[idx] = *kmv;
					idx += 2;
					++kmv;
				}
			}
			helpshown = true;
		}
		Base::print_view(helpview);
	}
	else if(clientstate != CS_TEAM_INFO)
	{
		Base::print_view(viewbuffer);
		if(clientstate == CS_AIMING)
			draw_aimer();
		if(showtitles)
			draw_titles();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfe71(%rip), %rax      # 0x28fe0
cmpl $0x3, (%rax)
jne 0x19185
leaq 0x3a35(%rip), %rdi      # 0x1cbb0
callq 0x9900
jmp 0x19261
leaq 0xfe54(%rip), %rax      # 0x28fe0
cmpl $0x4, (%rax)
jne 0x19224
testb $0x1, 0x12685(%rip)     # 0x2b821
jne 0x19216
movl $0x0, -0x10(%rbp)
cmpl $0x1b, -0x10(%rbp)
jge 0x1920f
movl -0x10(%rbp), %edi
callq 0x161e0
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x3e1d(%rip), %rax      # 0x1cfe0
movw (%rax,%rcx,2), %ax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x19202
movq -0x8(%rbp), %rax
movb (%rax), %dl
movswq -0xa(%rbp), %rcx
leaq 0xf34a(%rip), %rax      # 0x28530
movb %dl, (%rax,%rcx)
movswl -0xa(%rbp), %eax
addl $0x2, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x191cb
jmp 0x19204
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x191a5
movb $0x1, 0x1260b(%rip)     # 0x2b821
leaq 0xf313(%rip), %rdi      # 0x28530
callq 0x9900
jmp 0x1925f
leaq 0xfdb5(%rip), %rax      # 0x28fe0
cmpl $0x5, (%rax)
je 0x1925d
leaq 0x115e9(%rip), %rdi     # 0x2a820
callq 0x9900
leaq 0xfd9d(%rip), %rax      # 0x28fe0
cmpl $0x6, (%rax)
jne 0x1924d
callq 0x19460
testb $0x1, 0x125cc(%rip)     # 0x2b820
je 0x1925b
callq 0x18fc0
jmp 0x1925d
jmp 0x1925f
jmp 0x19261
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/view.cpp
// Function: diff_titles()
void diff_titles()
{
	// cf. "draw_titles()"
	char *pos = &(viewbuffer[VIEWSIZE*VIEWSIZE*2+1]);
	string s = "";
	for(char num = viewbuffer[VIEWSIZE*VIEWSIZE*2]; num > 0; --num)
	{
		if(*pos != VIEWSIZE/2 || *(pos+1) != VIEWSIZE/2 || !ClassCPV::im_alive())
		{
			s += (pos+2);
			s += ", ";
		}
		pos += strlen(pos+2)+3;
	}
	if(!s.empty())
		s.erase(s.size()-2);
	s.insert(0, "Titles: ");
	add_to_chat(s, "", T_NO_TEAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x119c1(%rip), %rax     # 0x2ac43
movq %rax, -0x8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5840
movq -0x70(%rbp), %rdx
leaq 0x31eb(%rip), %rsi      # 0x1c489
leaq -0x28(%rbp), %rdi
callq 0xa030
jmp 0x192a9
leaq -0x29(%rbp), %rdi
callq 0x5540
movb 0x1198a(%rip), %al      # 0x2ac42
movb %al, -0x3d(%rbp)
movsbl -0x3d(%rbp), %eax
cmpl $0x0, %eax
jle 0x1936c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xb, %eax
jne 0x192f4
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0xb, %eax
jne 0x192f4
callq 0xb3f0
movb %al, -0x71(%rbp)
jmp 0x192eb
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x19346
jmp 0x192f4
movq -0x8(%rbp), %rsi
addq $0x2, %rsi
leaq -0x28(%rbp), %rdi
callq 0x5480
jmp 0x19307
leaq 0x3882(%rip), %rsi      # 0x1cb90
leaq -0x28(%rbp), %rdi
callq 0x5480
jmp 0x19319
jmp 0x19346
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x5540
jmp 0x1944d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x19444
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x5230
addq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movb -0x3d(%rbp), %al
addb $-0x1, %al
movb %al, -0x3d(%rbp)
jmp 0x192bb
leaq -0x28(%rbp), %rdi
callq 0x57f0
testb $0x1, %al
jne 0x193a1
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5350
movq -0x80(%rbp), %rdi
movq %rax, %rsi
addq $-0x2, %rsi
movq $-0x1, %rdx
callq 0x5120
jmp 0x1939f
jmp 0x193a1
leaq 0x37eb(%rip), %rdx      # 0x1cb93
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x5140
jmp 0x193b7
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5840
movq -0x88(%rbp), %rdx
leaq 0x30b4(%rip), %rsi      # 0x1c489
leaq -0x60(%rbp), %rdi
callq 0xa030
jmp 0x193e0
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x3, %edx
callq 0xec80
jmp 0x193f4
leaq -0x60(%rbp), %rdi
callq 0x5968
leaq -0x61(%rbp), %rdi
callq 0x5540
leaq -0x28(%rbp), %rdi
callq 0x5968
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1943b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5968
leaq -0x61(%rbp), %rdi
callq 0x5540
leaq -0x28(%rbp), %rdi
callq 0x5968
movq -0x38(%rbp), %rdi
callq 0x5830
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/view.cpp
// Function: (anonymous namespace)::some_pc_at(char, char)
bool some_pc_at(const char x, const char y)
{
	if(viewbuffer[(y*VIEWSIZE+x)*2+1] == '@')
		return true;
	// sound-covered PCs must be checked separately
	if(viewbuffer[(y*VIEWSIZE+x)*2+1] == '!')
	{
		char *pos = &(viewbuffer[VIEWSIZE*VIEWSIZE*2+1]);
		for(char num = viewbuffer[VIEWSIZE*VIEWSIZE*2]; num > 0; --num)
		{
			if(x == *pos && y == *(pos+1))
				return true; // there is a PC behind this '!'
			pos += strlen(pos+2)+3; // same logic as above in draw_titles()
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movsbl -0x3(%rbp), %eax
imull $0x17, %eax, %eax
movsbl -0x2(%rbp), %ecx
addl %ecx, %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x10d80(%rip), %rax     # 0x2a820
movsbl (%rax,%rcx), %eax
cmpl $0x40, %eax
jne 0x19ab2
movb $0x1, -0x1(%rbp)
jmp 0x19b48
movsbl -0x3(%rbp), %eax
imull $0x17, %eax, %eax
movsbl -0x2(%rbp), %ecx
addl %ecx, %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x10d52(%rip), %rax     # 0x2a820
movsbl (%rax,%rcx), %eax
cmpl $0x21, %eax
jne 0x19b44
leaq 0x10d42(%rip), %rax     # 0x2a820
addq $0x423, %rax            # imm = 0x423
movq %rax, -0x10(%rbp)
movb 0x11154(%rip), %al      # 0x2ac42
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jle 0x19b42
movsbl -0x2(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x19b1f
movsbl -0x3(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x19b1f
movb $0x1, -0x1(%rbp)
jmp 0x19b48
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
callq 0x5230
addq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movb -0x11(%rbp), %al
addb $-0x1, %al
movb %al, -0x11(%rbp)
jmp 0x19af1
jmp 0x19b44
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::add(unsigned short)
void SerialBuffer::add(const unsigned short sh)
{
	// make sure we write big-endian:
	unsigned short conv = htons(sh);
	// break it up to chars (this, IMO, is clean if inefficient):
	unsigned char b = conv & 0xFF;
	add(b);
	add((b = (conv >> 8) & 0xFF));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x5070
movq -0x18(%rbp), %rdi
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %esi
callq 0x19c90
movq -0x18(%rbp), %rdi
movzwl -0xc(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movzbl %al, %esi
callq 0x19c90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void SerialBuffer::add(const string &str)
{
	copy(str.begin(), str.end(), pos);
	pos += str.size();
	*pos = '\0';
	++pos;
	num += str.size()+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5470
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdx
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a070
movq -0x10(%rbp), %rdi
callq 0x5350
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movb $0x0, (%rcx)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x5350
movq %rax, %rdx
movq -0x28(%rbp), %rax
addq $0x1, %rdx
movswq 0x8(%rax), %rcx
addq %rdx, %rcx
movw %cx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::write_compressed(char*, unsigned short)
void SerialBuffer::write_compressed(char *buffer, const unsigned short len)
{
	uLongf res_size = BUFFER_SIZE; // actually this is not how much room there is, but
	// we'll never run out of room here anyway.

	// leave room in the beginning for the size short
	compress((Bytef*)(pos+2), &res_size, (Bytef*)buffer, len);
	add((unsigned short)res_size); //NOTE: pos has not been moved, so this writes right before the compressed data
	pos += res_size;
	num += res_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x800, -0x20(%rbp)     # imm = 0x800
movq (%rax), %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rdx
movzwl -0x12(%rbp), %eax
movl %eax, %ecx
leaq -0x20(%rbp), %rsi
callq 0x5110
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movzwl %ax, %esi
callq 0x19cd0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rdx
movswq 0x8(%rax), %rcx
addq %rdx, %rcx
movw %cx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::read_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void SerialBuffer::read_str(string &target)
{
	// If we trusted the other end blindly, we could just do:
#if 0
	target.assign(pos);
	pos += target.size()+1;
#endif
	/* But alas, there are mean people out there who would abuse such a hole.
	 * Hence we enforce a maximum length of a string and read carefully
	 * one byte at a time (there might not be any '\0' in the buffer to end the
	 * string!) */
	target.clear();
	// Read (A) at most the maximum string length, (B) at most as much as there
	// is buffer left!
	short bs_read = 0;
	while(bs_read < MAXIMUM_STR_LEN && pos != arr+BUFFER_SIZE)
	{
		if(*pos == '\0')
		{
			++pos;
			break;
		}
		target += *pos;
		++pos;
		++bs_read;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x56c0
movw $0x0, -0x12(%rbp)
movswl -0x12(%rbp), %ecx
xorl %eax, %eax
cmpl $0x15e, %ecx            # imm = 0x15E
movb %al, -0x21(%rbp)
jge 0x19f23
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
addq $0xa, %rcx
addq $0x800, %rcx            # imm = 0x800
cmpq %rcx, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x19f2c
jmp 0x19f7f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x19f4b
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x19f7f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x52f0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x19ef7
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::read_compressed(char*)
bool SerialBuffer::read_compressed(char *buffer)
{
	// read the size of the block:
	unsigned short sh = read_sh();
	uLongf res_size = BUFFER_SIZE;
	int r = uncompress((Bytef*)buffer, &res_size, (Bytef*)pos, sh);
	if(r == Z_BUF_ERROR || r == Z_DATA_ERROR)
		return true;
	// Z_MEM_ERROR (insufficient memory) is highly unlikely and would cause more
	// general problems.
	pos += res_size;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x19e60
movw %ax, %cx
movq -0x38(%rbp), %rax
movw %cx, -0x1a(%rbp)
movq $0x800, -0x28(%rbp)     # imm = 0x800
movq -0x18(%rbp), %rdi
movq (%rax), %rdx
movzwl -0x1a(%rbp), %eax
movl %eax, %ecx
leaq -0x28(%rbp), %rsi
callq 0x51b0
movl %eax, -0x2c(%rbp)
cmpl $-0x5, -0x2c(%rbp)
je 0x19fe5
cmpl $-0x3, -0x2c(%rbp)
jne 0x19feb
movb $0x1, -0x1(%rbp)
jmp 0x19ffd
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
void del(string &s, const int n)
{
	string::iterator i = s.begin();
	advance(i, s, n);
	for(char c = seq_len(*i); c > 0; --c)
	{
		if((i = s.erase(i)) == s.end())
			break; /* If this happens, string is not proper UTF-8!
		            * We can't really do anything with such a string;
					* this is just to avoid nasty segfaults. */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
leaq -0x18(%rbp), %rdi
movswl %ax, %edx
callq 0x1a320
leaq -0x18(%rbp), %rdi
callq 0x18170
movsbl (%rax), %edi
callq 0x1a410
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jle 0x1a318
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1ab80
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5610
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52c0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x189f0
testb $0x1, %al
jne 0x1a30a
jmp 0x1a30c
jmp 0x1a318
jmp 0x1a30e
movb -0x19(%rbp), %al
addb $-0x1, %al
movb %al, -0x19(%rbp)
jmp 0x1a2b3
addq $0x40, %rsp
popq %rbp
retq
nop