LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: arush15june[P]DFA-CPP/dfa.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> split(const std::string &s, char delim) {
    std::stringstream ss(s);
    std::string item;
    std::vector<std::string> elems;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
        // elems.push_back(std::move(item)); // if C++11 (based on comment from @mchiasson)
    }
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x3720
movq -0x1e8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0x2240
leaq -0x1c0(%rbp), %rdi
callq 0x2200
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
callq 0x3740
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x22a0
movq %rax, -0x1f8(%rbp)
jmp 0x2487
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21e0
movb %al, -0x1f9(%rbp)
jmp 0x24a5
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x24b1
jmp 0x2500
movq -0x1e0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3760
jmp 0x24c6
jmp 0x2467
movq -0x1e0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
callq 0x37d0
leaq -0x1c0(%rbp), %rdi
callq 0x2110
leaq -0x1a0(%rbp), %rdi
callq 0x2120
jmp 0x2544
movb $0x1, -0x1c1(%rbp)
testb $0x1, -0x1c1(%rbp)
jne 0x251c
movq -0x1e0(%rbp), %rdi
callq 0x37d0
leaq -0x1c0(%rbp), %rdi
callq 0x2110
leaq -0x1a0(%rbp), %rdi
callq 0x2120
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x2280
// File: arush15june[P]DFA-CPP/dfa.cpp
// Function: StateDiagram::insertEdge(int, int, int)
void insertEdge(int state_no, int weight, int y) {
        /*
            Add edge to an adjacency list.

            @param int state_no: state to add to
            @param int weight: weight of edge
            @param int y: state no of edge
        */
        
        auto pair = std::make_pair(weight, y);
        auto& state = states[state_no];
        
        state.push_back(pair);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x41e0
movq -0x30(%rbp), %rdi
movq %rax, -0x1c(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x4210
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x4240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: arush15june[P]DFA-CPP/dfa.cpp
// Function: DFA::execute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool execute(std::string input) {
        /*
        Execute the DFA over the input string.

        TODO: Templatize for any type of vector of input symbols

        Algorithm
            1) set current state to q i.e initial state of DFA.
            2) Iterate over the string.
                a) get the adjacency list for the current state.
                b) Iterate over the adjancency list
                    i) if the state's weight is same as the current symbols ASCII value
                        set the current state to the state's no and break the iteration.
            3) If the current state is same as the final state, set the final_state_reached flag true
            4) return final_state_reached

        @param std::string input: Input string to execute DFA on.
        @return bool final_state_reached: True if the final state was reached, else False.
        */

        bool final_state_reached = false;
        int current_state = q; 

        for(char symbol: input) {
            auto symbol_val = int(symbol);
            auto curr_adj_list = state_diagram.getState(current_state);

            for(auto &state: curr_adj_list) {
                if(state.first == symbol_val and state.second != current_state) {
                    current_state = state.second;
                    break;
                }
            }
        }


        if(current_state == f) final_state_reached = true;

        return final_state_reached;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
movl 0x6d88(%rax), %eax
movl %eax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2150
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5d70
testb $0x1, %al
jne 0x3bac
jmp 0x3c5a
leaq -0x28(%rbp), %rdi
callq 0x40b0
movq -0x78(%rbp), %rsi
movb (%rax), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x18(%rbp), %edx
leaq -0x50(%rbp), %rdi
callq 0x5db0
leaq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x4620
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x44b0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5e00
testb $0x1, %al
jne 0x3c06
jmp 0x3c43
leaq -0x60(%rbp), %rdi
callq 0x5e40
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movl (%rax), %eax
cmpl -0x38(%rbp), %eax
jne 0x3c36
movq -0x70(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
je 0x3c36
movq -0x70(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x3c43
jmp 0x3c38
leaq -0x60(%rbp), %rdi
callq 0x5e60
jmp 0x3bf3
leaq -0x50(%rbp), %rdi
callq 0x5ab0
leaq -0x28(%rbp), %rdi
callq 0x4090
jmp 0x3b96
movq -0x78(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x6d8c(%rcx), %eax
jne 0x3c6d
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: LangProc[P]langproc_2015_cw/src/c_lexer.yy.c
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 10 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 9);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x6472(%rip), %rax      # 0x9240
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x334f(%rip), %rax      # 0x6130
cmpw $0x0, (%rax,%rcx,2)
je 0x2dfc
movl -0x4(%rbp), %eax
movl %eax, 0x645b(%rip)      # 0x924c
movq -0x10(%rbp), %rax
movq %rax, 0x6454(%rip)      # 0x9250
jmp 0x2dfe
movslq -0x4(%rbp), %rcx
leaq 0x3367(%rip), %rax      # 0x6170
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3333(%rip), %rax      # 0x6150
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x2e53
movslq -0x4(%rbp), %rcx
leaq 0x335f(%rip), %rax      # 0x6190
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jl 0x2e51
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x335b(%rip), %rax      # 0x61a6
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x2dfe
movslq -0x4(%rbp), %rcx
leaq 0x3312(%rip), %rax      # 0x6170
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x333e(%rip), %rax      # 0x61b0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x9, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x2e95
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x2e9b
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::ECM_Sketch(int, int)
ECM_Sketch(int _w, int _d)
	{
		mem_acc = 0;
		counter_index_size = 20;
		w = _w;
		d = _d;
		
		for(int i = 0; i < d; i++)	
		{
			counter[i] = new Counter[w];
			memset(counter[i], -1, sizeof(Counter) * w);
		}

		MAX_CNT = (1 << COUNTER_SIZE) - 1;

		for(int i = 0; i < d; i++)
		{
			bobhash32[i] = new BOBHash32(i);
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1a8(%rax)
movl $0x14, 0x19c(%rax)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x190(%rax)
movl 0x28(%rsp), %ecx
movl %ecx, 0x194(%rax)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x194(%rcx), %eax
jge 0x34d3
movq 0x8(%rsp), %rax
movslq 0x190(%rax), %rax
movl $0x4b4, %ecx            # imm = 0x4B4
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq %rdx, 0xf0(%rax,%rcx,8)
movslq 0x24(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rdi
movslq 0x190(%rax), %rax
imulq $0x4b4, %rax, %rdx      # imm = 0x4B4
movl $0xff, %esi
callq 0x20c0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x344b
movq 0x8(%rsp), %rax
movl $0xffff, 0x198(%rax)    # imm = 0xFFFF
movl $0x0, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x194(%rcx), %eax
jge 0x3552
movl $0x4, %edi
callq 0x2150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl 0x20(%rsp), %esi
callq 0x23f0
jmp 0x351a
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
movslq 0x20(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x34ea
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x2130
jmp 0x3557
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Insert(char const*, int)
void Insert(const char * str, int t)
	{
		for(int i = 0; i < d; i++)
		{
			index[i] = (bobhash32[i]->run(str, strlen(str))) % w;

			Expire_bucket(i, index[i], t);
			Insert_bucket(i, index[i], t);

			mem_acc ++;
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x194(%rcx), %eax
jge 0x3655
movq 0x18(%rsp), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0x2430
movq 0x18(%rsp), %rdi
xorl %edx, %edx
divl 0x190(%rdi)
movslq 0x20(%rsp), %rax
movl %edx, 0xa0(%rdi,%rax,4)
movl 0x20(%rsp), %esi
movslq 0x20(%rsp), %rax
movl 0xa0(%rdi,%rax,4), %edx
movl 0x24(%rsp), %ecx
callq 0x3e30
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
movslq 0x20(%rsp), %rax
movl 0xa0(%rdi,%rax,4), %edx
movl 0x24(%rsp), %ecx
callq 0x3fb0
movq 0x18(%rsp), %rax
movl 0x1a8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1a8(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x3594
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Query(char const*, int)
int Query(const char *str, int t)
	{
		int min_value = MAX_CNT;
		int temp;
		for(int i = 0; i < d; i++)
		{
			index[i] = (bobhash32[i]->run(str, strlen(str))) % w;
			Expire_bucket(i, index[i], t);
			temp = Bucket_sum(i, index[i], t);
			min_value = temp < min_value ? temp : min_value;
		}
		return min_value;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x198(%rax), %eax
movl %eax, 0x30(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x194(%rcx), %eax
jge 0x3763
movq 0x20(%rsp), %rax
movslq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x20a0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %eax, %edx
callq 0x2430
movq 0x20(%rsp), %rdi
xorl %edx, %edx
divl 0x190(%rdi)
movslq 0x28(%rsp), %rax
movl %edx, 0xa0(%rdi,%rax,4)
movl 0x28(%rsp), %esi
movslq 0x28(%rsp), %rax
movl 0xa0(%rdi,%rax,4), %edx
movl 0x34(%rsp), %ecx
callq 0x3e30
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
movslq 0x28(%rsp), %rax
movl 0xa0(%rdi,%rax,4), %edx
movl 0x34(%rsp), %ecx
callq 0x4a00
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x3743
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x374b
movl 0x30(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x368e
movl 0x30(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Expire_bucket(int, int, int)
void Expire_bucket(int i, int j, int t)
	{
		int z = counter[i][j].number - 1;
		if (z != -2)
		{
			for (int q = z; q >= 0; q--)
			{
				if (counter[i][j].bucket[q].end <= (t - WINDOW_SIZE))
				{
					counter[i][j].bucket[q].exponent = -1;
					counter[i][j].bucket[q].start = -1;
					counter[i][j].bucket[q].end = -1;
					counter[i][j].number--;
				}
				else
				{
					break;
				}
			}
		}
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movslq -0xc(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rax
movslq -0x10(%rsp), %rcx
imulq $0x4b4, %rcx, %rcx      # imm = 0x4B4
addq %rcx, %rax
movl 0x4b0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rsp)
cmpl $-0x2, -0x18(%rsp)
je 0x3fa8
movl -0x18(%rsp), %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
jl 0x3fa6
movq -0x28(%rsp), %rax
movslq -0xc(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rax
movslq -0x10(%rsp), %rcx
imulq $0x4b4, %rcx, %rcx      # imm = 0x4B4
addq %rcx, %rax
movslq -0x1c(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl -0x14(%rsp), %ecx
subl $0x493e0, %ecx          # imm = 0x493E0
cmpl %ecx, %eax
jg 0x3f92
movq -0x28(%rsp), %rax
movslq -0xc(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rcx
movslq -0x10(%rsp), %rdx
imulq $0x4b4, %rdx, %rdx      # imm = 0x4B4
addq %rdx, %rcx
movslq -0x1c(%rsp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
movslq -0xc(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rcx
movslq -0x10(%rsp), %rdx
imulq $0x4b4, %rdx, %rdx      # imm = 0x4B4
addq %rdx, %rcx
movslq -0x1c(%rsp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl $0xffffffff, 0x8(%rcx)  # imm = 0xFFFFFFFF
movslq -0xc(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rcx
movslq -0x10(%rsp), %rdx
imulq $0x4b4, %rdx, %rdx      # imm = 0x4B4
addq %rdx, %rcx
movslq -0x1c(%rsp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl $0xffffffff, 0x4(%rcx)  # imm = 0xFFFFFFFF
movslq -0xc(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rax
movslq -0x10(%rsp), %rcx
imulq $0x4b4, %rcx, %rcx      # imm = 0x4B4
addq %rcx, %rax
movl 0x4b0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4b0(%rax)
jmp 0x3f94
jmp 0x3fa6
jmp 0x3f96
movl -0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x3e87
jmp 0x3fa8
retq
nopl (%rax)
// File: shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Bucket_sum(int, int, int)
int Bucket_sum(int i, int j, int t)
	{
		int z = counter[i][j].number;
		if (z == -1)
		{
			return 0;
		}
		else
		{
			int exp;
			int count_bucket = 1;
			int count = 0;
			int q;
			for (q = 0; q < z - 1; ++q)
			{
				exp = counter[i][j].bucket[q].exponent;
				for (int k = 0; k < exp; ++k)
				{
					count_bucket = 2 * count_bucket;
				}
				count = count + count_bucket;
				count_bucket = 1;
			}
			for (int k = 0; k < counter[i][j].bucket[q].exponent; ++k)
			{
				count_bucket = 2 * count_bucket;
			}
			
			count = count + count_bucket / 2;

			return count;
		}
	}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x40(%rsp)
movslq -0x14(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rax
movslq -0x18(%rsp), %rcx
imulq $0x4b4, %rcx, %rcx      # imm = 0x4B4
addq %rcx, %rax
movl 0x4b0(%rax), %eax
movl %eax, -0x20(%rsp)
cmpl $-0x1, -0x20(%rsp)
jne 0x4a55
movl $0x0, -0x4(%rsp)
jmp 0x4b7c
movl $0x1, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movl $0x0, -0x30(%rsp)
movl -0x30(%rsp), %eax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4b00
movq -0x40(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rax
movslq -0x18(%rsp), %rcx
imulq $0x4b4, %rcx, %rcx      # imm = 0x4B4
addq %rcx, %rax
movslq -0x30(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x24(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
cmpl -0x24(%rsp), %eax
jge 0x4adc
movl -0x28(%rsp), %eax
shll %eax
movl %eax, -0x28(%rsp)
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x4abb
movl -0x2c(%rsp), %eax
addl -0x28(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl $0x1, -0x28(%rsp)
movl -0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0x4a6d
movl $0x0, -0x38(%rsp)
movq -0x40(%rsp), %rcx
movl -0x38(%rsp), %eax
movslq -0x14(%rsp), %rdx
movq 0xf0(%rcx,%rdx,8), %rcx
movslq -0x18(%rsp), %rdx
imulq $0x4b4, %rdx, %rdx      # imm = 0x4B4
addq %rdx, %rcx
movslq -0x30(%rsp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0x4b54
movl -0x28(%rsp), %eax
shll %eax
movl %eax, -0x28(%rsp)
movl -0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rsp)
jmp 0x4b08
movl -0x2c(%rsp), %eax
movl %eax, -0x44(%rsp)
movl -0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x44(%rsp), %eax
addl %ecx, %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/mcd.c
// Function: mcd
static int mcd(int n,int d)
{
  int N,D,R;
  N=abs(n);D=abs(d);
  while((R=D%N)!=0){
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
    D=N;
    N=R;
  }
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  return N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, %edx
je 0x11f6
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xe23(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x11b8
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xdf4(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/main.c
// Function: main
int main(void){
  int result=printf("mcd(32,132)=%d\n",mcd(32,132));
  printf("mcd(8,64)=%d\n",mcd(8,64));
  printf("mcd(65,2048)=%d\n",mcd(65,2048));

  int m=mcd(32,132);
  int arr[]={32,132};
  simplificar(arr);
  printf("32/132=%d/%d\n",arr[0],arr[1]);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x20, %edi
movl $0x84, %esi
callq 0x12e0
movl %eax, %esi
leaq 0xdcd(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
movl %eax, -0x8(%rbp)
movl $0x8, %edi
movl $0x40, %esi
callq 0x12e0
movl %eax, %esi
leaq 0xdbb(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1030
movl $0x41, %edi
movl $0x800, %esi            # imm = 0x800
callq 0x12e0
movl %eax, %esi
leaq 0xdaa(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1030
movl $0x20, %edi
movl $0x84, %esi
callq 0x12e0
movl %eax, -0xc(%rbp)
movq 0xdac(%rip), %rax       # 0x2054
movq %rax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x1140
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0xd81(%rip), %rdi       # 0x2043
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/otro.c
// Function: mcd
int mcd(int n,int d)
{
  int N,D,R;
  N=abs(n);
  D=abs(d);
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
fin:
  return N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x131d
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xccd(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x135f
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xc8b(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x139e
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xc4c(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x13dd
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xc0d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/class.cc
// Function: main
int main()
{
    std::string s;

    // ok: calls std::getline(std::istream&, const std::string&)
    getline(std::cin, s);

	std::cout << s << std::endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1080
movq -0x40(%rbp), %rsi
movq 0x2dc9(%rip), %rdi      # 0x3fe0
callq 0x1030
jmp 0x121e
movq 0x2dab(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1060
movq %rax, -0x48(%rbp)
jmp 0x1234
movq -0x48(%rbp), %rdi
movq 0x2d81(%rip), %rsi      # 0x3fc0
callq 0x1070
jmp 0x1246
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movq -0x30(%rbp), %rdi
callq 0x10a0
// File: lotuskip[P]yuxtapa/server/server.cpp
// Function: (anonymous namespace)::goto_next_map()
void goto_next_map()
{
	intermission = false;
	turns_lagged = 0;
	Game::start();
	last_clock.update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x756a5(%rip)     # 0x8d530
movw $0x0, 0x75dac(%rip)     # 0x8dc40
callq 0x37f40
leaq 0x75d90(%rip), %rdi     # 0x8dc30
callq 0x5f260
popq %rbp
retq
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/server.cpp
// Function: (anonymous namespace)::goto_intermission(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void goto_intermission(const string &loadmap)
{
	intermission = true;
	Game::next_map(loadmap);
	if(turns_lagged)
	{
		string str = "Warning: the server lagged "
			+ lex_cast(turns_lagged) + " turns this map.";
		to_log(str);
	}
	interm_over = time(NULL) + Config::int_settings[Config::IS_INTERM_SECS];
	Network::clocksync(interm_over - time(NULL), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, 0x7566a(%rip)     # 0x8d530
movq -0x8(%rbp), %rdi
callq 0x36320
cmpw $0x0, 0x75d69(%rip)     # 0x8dc40
je 0x17f8a
movswl 0x75d5c(%rip), %esi     # 0x8dc40
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x609d0
movq -0x80(%rbp), %rdx
leaq 0x49301(%rip), %rsi     # 0x611fd
leaq -0x48(%rbp), %rdi
callq 0x18a90
jmp 0x17f07
leaq 0x4930b(%rip), %rdx     # 0x61219
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x18a40
jmp 0x17f1d
leaq -0x48(%rbp), %rdi
callq 0x5a48
leaq -0x68(%rbp), %rdi
callq 0x5a48
leaq -0x28(%rbp), %rdi
callq 0x28d70
jmp 0x17f3a
leaq -0x28(%rbp), %rdi
callq 0x5a48
jmp 0x17f8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x17f68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5a48
leaq -0x68(%rbp), %rdi
callq 0x5a48
jmp 0x17fde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5a48
jmp 0x17fde
xorl %eax, %eax
movl %eax, %edi
callq 0x54c0
leaq 0x77a76(%rip), %rcx     # 0x8fa10
movl 0x18(%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x75c81(%rip)     # 0x8dc28
movq 0x75c7a(%rip), %rax     # 0x8dc28
movq %rax, -0x88(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x54c0
movq %rax, %rcx
movq -0x88(%rbp), %rax
subq %rcx, %rax
xorl %esi, %esi
movzwl %ax, %edi
callq 0x1af90
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5920
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/network.cpp
// Function: Network::shutdown()
void Network::shutdown()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_QUIT);
	broadcast();
	close(s_me);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7516d(%rip), %rdi     # 0x8e298
callq 0x5f370
leaq 0x75161(%rip), %rdi     # 0x8e298
movl $0x2, %esi
callq 0x5f390
movl $0xffff, %edi           # imm = 0xFFFF
leaq 0x7514b(%rip), %rsi     # 0x8e298
callq 0x19160
movl 0x76160(%rip), %edi     # 0x8f2b8
callq 0x59e0
popq %rbp
retq
nop
// File: lotuskip[P]yuxtapa/server/network.cpp
// Function: Network::construct_msg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned char)
void Network::construct_msg(string &s, const unsigned char cpair)
{
	/* Note: all message are server-generated, and pretty much the only content
	 * unknown at compile time and beyond the admin's control are the player nicks,
	 * which have limited lenght. Hence, we can rest assured that the strings do
	 * not contain words of lenght > MSG_WIN_X (=57). */
	vector<string> blocks;
	size_t i;
	// break up at spaces:
	while(num_syms(s) > MSG_WIN_X)
	{
		if((i = s.rfind(' ', MSG_WIN_X)) == string::npos)
			i = MSG_WIN_X;
		blocks.push_back(s.substr(0, i));
		s.erase(0, i+1);
	}
	if(!s.empty())
		blocks.push_back(s);
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_ADD_MSG);
	send_buffer.add(cpair);
	send_buffer.add((unsigned char)blocks.size());
	for(i = 0; i < blocks.size(); ++i)
		send_buffer.add(blocks[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b3e0
movq -0x8(%rbp), %rdi
callq 0x5fe20
movw %ax, -0x62(%rbp)
jmp 0x1ab3a
movw -0x62(%rbp), %ax
cwtl
cmpl $0x39, %eax
jle 0x1abe4
movq -0x8(%rbp), %rdi
movl $0x20, %esi
movl $0x39, %edx
callq 0x59f0
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
jne 0x1ab80
movq $0x39, -0x30(%rbp)
jmp 0x1ab80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1acb1
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rdi
callq 0x5540
jmp 0x1ab97
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1b400
jmp 0x1aba6
leaq -0x60(%rbp), %rdi
callq 0x5a48
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
incq %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x5120
jmp 0x1abc5
jmp 0x1ab2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5a48
jmp 0x1acb1
movq -0x8(%rbp), %rdi
callq 0x58d0
testb $0x1, %al
jne 0x1ac02
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1b430
jmp 0x1ac00
jmp 0x1ac02
leaq 0x7368f(%rip), %rdi     # 0x8e298
callq 0x5f370
jmp 0x1ac10
leaq 0x73681(%rip), %rdi     # 0x8e298
movl $0xa, %esi
callq 0x5f390
jmp 0x1ac23
movzbl -0x9(%rbp), %esi
leaq 0x7366a(%rip), %rdi     # 0x8e298
callq 0x5f390
jmp 0x1ac35
leaq -0x28(%rbp), %rdi
callq 0x1b4a0
movzbl %al, %esi
leaq 0x73650(%rip), %rdi     # 0x8e298
callq 0x5f390
jmp 0x1ac4f
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b4a0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x1aca2
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1b4c0
movq %rax, %rsi
leaq 0x7360d(%rip), %rdi     # 0x8e298
callq 0x5f440
jmp 0x1ac92
jmp 0x1ac94
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1ac57
leaq -0x28(%rbp), %rdi
callq 0x1b4e0
addq $0x70, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x1b4e0
movq -0x38(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/network.cpp
// Function: Network::to_chat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Network::to_chat(const string &s)
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_SAY_CHAT);
	send_buffer.add((unsigned short)0);
	send_buffer.add(s);
	send_buffer.add(string("* "));
	send_buffer.add((unsigned char)T_NO_TEAM); // no team, server speaking
	broadcast();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x735b5(%rip), %rdi     # 0x8e298
movq %rdi, -0x50(%rbp)
callq 0x5f370
movq -0x50(%rbp), %rdi
movl $0x4, %esi
callq 0x5f390
movq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x5f3d0
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5f440
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5930
movq -0x48(%rbp), %rdx
leaq 0x46610(%rip), %rsi     # 0x6133a
leaq -0x28(%rbp), %rdi
callq 0x18880
jmp 0x1ad35
leaq 0x7355c(%rip), %rdi     # 0x8e298
leaq -0x28(%rbp), %rsi
callq 0x5f440
jmp 0x1ad47
leaq -0x28(%rbp), %rdi
callq 0x5a48
leaq -0x29(%rbp), %rdi
callq 0x5590
leaq 0x73538(%rip), %rdi     # 0x8e298
movl $0x3, %esi
callq 0x5f390
movl $0xffff, %edi           # imm = 0xFFFF
leaq 0x73522(%rip), %rsi     # 0x8e298
callq 0x19160
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1ada4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5a48
leaq -0x29(%rbp), %rdi
callq 0x5590
movq -0x38(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/network.cpp
// Function: (anonymous namespace)::who_is_this()
list<Player>::iterator who_is_this()
{
	unsigned short pid = recv_buffer.read_sh();
	for(list<Player>::iterator it = cur_players.begin(); it != cur_players.end(); ++it)
	{
		if(it->stats_i->ID == pid)
			return it;
		/* NOTE: in principle, a malignant client could register as one player and
		 * afterwards ID as another... A remedy would be to check the address, but
		 * atm it seems unnecessary. */
	}
	return cur_players.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x73cd9(%rip), %rdi     # 0x8eaa8
callq 0x5f560
movw %ax, -0xa(%rbp)
leaq 0x75451(%rip), %rdi     # 0x90230
callq 0x1b360
movq %rax, -0x8(%rbp)
leaq 0x75441(%rip), %rdi     # 0x90230
callq 0x189f0
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1b100
testb $0x1, %al
jne 0x1ae0b
jmp 0x1ae3d
leaq -0x8(%rbp), %rdi
callq 0x1b050
movq %rax, %rdi
addq $0x80, %rdi
callq 0x1b390
movzwl (%rax), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1ae30
jmp 0x1ae4d
jmp 0x1ae32
leaq -0x8(%rbp), %rdi
callq 0x1b3c0
jmp 0x1ade8
leaq 0x753ec(%rip), %rdi     # 0x90230
callq 0x189f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/network.cpp
// Function: Network::clocksync(unsigned short, unsigned char)
void Network::clocksync(const unsigned short time, const unsigned char spawn)
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_TIME_UPD);
	send_buffer.add(time);
	send_buffer.add(spawn);
	broadcast();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, -0x2(%rbp)
movb %al, -0x3(%rbp)
leaq 0x732ec(%rip), %rdi     # 0x8e298
callq 0x5f370
leaq 0x732e0(%rip), %rdi     # 0x8e298
movl $0xe, %esi
callq 0x5f390
leaq 0x732cf(%rip), %rdi     # 0x8e298
movzwl -0x2(%rbp), %esi
callq 0x5f3d0
leaq 0x732bf(%rip), %rdi     # 0x8e298
movzbl -0x3(%rbp), %esi
callq 0x5f390
movl $0xffff, %edi           # imm = 0xFFFF
leaq 0x732aa(%rip), %rsi     # 0x8e298
callq 0x19160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/server/settings.cpp
// Function: (anonymous namespace)::validate_int_set(int)
bool validate_int_set(const int i)
{
	using namespace Config;
	if(i == IS_IPV)
		return (int_settings[IS_IPV] != 0 && int_settings[IS_IPV] != 4
			&& int_settings[IS_IPV] != 6);
	return (int_settings[i] < hard_lims[i][0] || int_settings[i] > hard_lims[i][1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jne 0x1e360
xorl %eax, %eax
cmpl $0x0, 0x716fa(%rip)     # 0x8fa30
movb %al, -0x9(%rbp)
je 0x1e356
xorl %eax, %eax
cmpl $0x4, 0x716ec(%rip)     # 0x8fa30
movb %al, -0x9(%rbp)
je 0x1e356
cmpl $0x6, 0x716e0(%rip)     # 0x8fa30
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1e3ae
movslq -0x8(%rbp), %rcx
leaq 0x716a5(%rip), %rax     # 0x8fa10
movl (%rax,%rcx,4), %ecx
movslq -0x8(%rbp), %rsi
movb $0x1, %al
leaq 0x433e5(%rip), %rdx     # 0x61760
cmpl (%rdx,%rsi,8), %ecx
movb %al, -0xa(%rbp)
jb 0x1e3a6
movslq -0x8(%rbp), %rcx
leaq 0x71682(%rip), %rax     # 0x8fa10
movl (%rax,%rcx,4), %eax
movslq -0x8(%rbp), %rdx
leaq 0x433c4(%rip), %rcx     # 0x61760
cmpl 0x4(%rcx,%rdx,8), %eax
seta %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/settings.cpp
// Function: (anonymous namespace)::validate_classlim()
bool validate_classlim()
{
	using namespace Config;
	if(int_settings[IS_CLASSLIMIT]
		&& int_settings[IS_CLASSLIMIT]*2*NO_CLASS < int_settings[IS_MAXPLAYERS])
	{
		int_settings[IS_CLASSLIMIT] = 0;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x71655(%rip)     # 0x8fa20
je 0x1e3f0
movl 0x7164d(%rip), %eax     # 0x8fa20
shll %eax
imull $0xb, %eax, %eax
cmpl 0x71632(%rip), %eax     # 0x8fa10
jae 0x1e3f0
movl $0x0, 0x71636(%rip)     # 0x8fa20
movb $0x1, -0x1(%rbp)
jmp 0x1e3f4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/settings.cpp
// Function: (anonymous namespace)::validate_minp()
bool validate_minp()
{
	using namespace Config;
	if(int_settings[IS_MINPLAYERS] > int_settings[IS_MAXPLAYERS]
		|| (int_settings[IS_MINPLAYERS] && !botexe.length()))
	{
		int_settings[IS_MINPLAYERS] = 0;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x7162e(%rip), %eax     # 0x8fa3c
cmpl 0x715fc(%rip), %eax     # 0x8fa10
ja 0x1e431
cmpl $0x0, 0x7161f(%rip)     # 0x8fa3c
je 0x1e441
leaq 0x7153a(%rip), %rdi     # 0x8f960
callq 0x57e0
cmpq $0x0, %rax
jne 0x1e441
movl $0x0, 0x71601(%rip)     # 0x8fa3c
movb $0x1, -0x1(%rbp)
jmp 0x1e445
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: lotuskip[P]yuxtapa/server/settings.cpp
// Function: (anonymous namespace)::construct_value_list(std::vector<char, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*)
string construct_value_list(const vector<char> &l, string const* const s)
{
	string ret = "";
	for(vector<char>::const_iterator it = l.begin(); it != l.end(); ++it)
		ret += s[*it] + '/';
	ret.erase(ret.size()-1, 1);
	if(ret.size() > MAX_LIST_LEN)
	{
		ret.erase(ret.rfind('/', MAX_LIST_LEN-4));
		ret += "...";
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5930
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x422da(%rip), %rsi     # 0x6133c
callq 0x18880
jmp 0x1f069
leaq -0x1a(%rbp), %rdi
callq 0x5590
movq -0x10(%rbp), %rdi
callq 0x1fbe0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1fc50
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fc10
testb $0x1, %al
jne 0x1f0a2
jmp 0x1f13a
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1fd00
movq -0x80(%rbp), %rsi
movsbq (%rax), %rax
shlq $0x5, %rax
addq %rax, %rsi
leaq -0x60(%rbp), %rdi
movl $0x2f, %edx
callq 0x1fc80
jmp 0x1f0d2
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x56e0
jmp 0x1f0e1
leaq -0x60(%rbp), %rdi
callq 0x5a48
leaq -0x38(%rbp), %rdi
callq 0x1fd20
jmp 0x1f07f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x5590
jmp 0x1f1cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1f1c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5a48
jmp 0x1f1c4
movq -0x70(%rbp), %rdi
callq 0x5340
movq -0x70(%rbp), %rdi
movq %rax, %rsi
decq %rsi
movl $0x1, %edx
callq 0x5120
jmp 0x1f159
movq -0x70(%rbp), %rdi
callq 0x5340
cmpq $0x50, %rax
jbe 0x1f1a4
movq -0x70(%rbp), %rdi
movl $0x2f, %esi
movl $0x4c, %edx
callq 0x59f0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movq $-0x1, %rdx
callq 0x5120
jmp 0x1f190
movq -0x70(%rbp), %rdi
leaq 0x4d91e(%rip), %rsi     # 0x6cab9
callq 0x54f0
jmp 0x1f1a2
jmp 0x1f1a4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1f1b7
movq -0x70(%rbp), %rdi
callq 0x5a48
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5a48
movq -0x28(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/sighandle.cpp
// Function: reg_sig_handlers()
void reg_sig_handlers()
{
	struct sigaction sa;
	sa.sa_handler = handle_signal;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;
	// List here all signals we're interested in:
	sigaction(SIGINT, &sa, 0);
	sigaction(SIGQUIT, &sa, 0);

	// Child processes would be bots. Let them be reaped:
	signal(SIGCHLD, SIG_IGN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x6e(%rip), %rax        # 0x21a90
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x5680
movl $0x0, -0x10(%rbp)
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5690
movl $0x3, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5690
movl $0x11, %edi
movl $0x1, %esi
callq 0x5610
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/players.cpp
// Function: PlayerStats::PlayerStats()
PlayerStats::PlayerStats() : last_known_as(""), deaths(0), tks(0),
	healing_recvd(0), total_time(0), time_specced(0), arch_hits(0),
	arch_shots(0), cm_hits(0), cm_shots(0), ad_lvl(AL_GUEST)
{
	int i;
	for(i = 0; i < NO_CLASS; ++i)
		time_played[i] = 0;
	for(i = 0; i < MAX_WAY_TO_KILL; ++i)
		kills[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x10, %rax
movq %rax, -0x30(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5930
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x3f824(%rip), %rsi     # 0x6133c
callq 0x18880
jmp 0x21b1f
leaq -0x9(%rbp), %rdi
callq 0x5590
movq -0x38(%rbp), %rax
movq $0x0, 0x30(%rax)
movq $0x0, 0x90(%rax)
movq $0x0, 0x98(%rax)
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movq $0x0, 0x108(%rax)
movq $0x0, 0x110(%rax)
movq $0x0, 0x118(%rax)
movq $0x0, 0x120(%rax)
movl $0x0, 0x130(%rax)
movl $0x0, -0x20(%rbp)
cmpl $0xb, -0x20(%rbp)
jge 0x21bd9
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq $0x0, 0xb0(%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x21b9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x5590
jmp 0x21c08
movl $0x0, -0x20(%rbp)
cmpl $0xb, -0x20(%rbp)
jge 0x21c02
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq $0x0, 0x38(%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x21be0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/players.cpp
// Function: Player::burn_torch()
bool Player::burn_torch()
{
	--torch_left;
	if(torch_left == 3*TORCH_DURATION/2 || torch_left == TORCH_DURATION/2
		|| torch_left == TORCH_DURATION || !torch_left)
		needs_state_upd = true;
	return !torch_left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movw 0x160(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x160(%rax)
movswl 0x160(%rax), %eax
cmpl $0x2ee, %eax            # imm = 0x2EE
je 0x21e52
movq -0x10(%rbp), %rax
movswl 0x160(%rax), %eax
cmpl $0xfa, %eax
je 0x21e52
movq -0x10(%rbp), %rax
movswl 0x160(%rax), %eax
cmpl $0x1f4, %eax            # imm = 0x1F4
je 0x21e52
movq -0x10(%rbp), %rax
cmpw $0x0, 0x160(%rax)
jne 0x21e5d
movq -0x10(%rbp), %rax
movb $0x1, 0x14d(%rax)
movq -0x10(%rbp), %rax
cmpw $0x0, 0x160(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/players.cpp
// Function: Player::torch_symbol(bool) const
unsigned char Player::torch_symbol(const bool lit) const
{
	if(cl_props.torch)
	{
		if(!torch_left)
			return ',';
		if(lit)
			return torch_sym[2*torch_left/TORCH_DURATION];
		return ' '; // torch not lit
	}
	return '-'; // no torch whatsoever
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x14b(%rax)
je 0x21ee8
movq -0x20(%rbp), %rax
cmpw $0x0, 0x160(%rax)
jne 0x21eb5
movb $0x2c, -0x1(%rbp)
jmp 0x21eec
testb $0x1, -0x11(%rbp)
je 0x21ee2
movq -0x20(%rbp), %rax
movswl 0x160(%rax), %eax
shll %eax
movl $0x1f4, %ecx            # imm = 0x1F4
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0x3fb85(%rip), %rax     # 0x61a5f
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x21eec
movb $0x20, -0x1(%rbp)
jmp 0x21eec
movb $0x2d, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/players.cpp
// Function: (anonymous namespace)::find_pl_by_sas(sockaddr_storage const&)
list<Player>::const_iterator find_pl_by_sas(const sockaddr_storage &sas)
{
	list<Player>::const_iterator i = cur_players.begin();
	for(; i != cur_players.end(); ++i)
	{
		if(equal_sas(&(i->address), &sas))
			break;
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x6cfed(%rip), %rdi     # 0x90230
callq 0x1b360
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x18a20
leaq 0x6cfd0(%rip), %rdi     # 0x90230
callq 0x189f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x18a20
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x24f10
testb $0x1, %al
jne 0x23289
jmp 0x232b3
leaq -0x8(%rbp), %rdi
callq 0x24f40
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x24860
testb $0x1, %al
jne 0x232a4
jmp 0x232a6
jmp 0x232b3
jmp 0x232a8
leaq -0x8(%rbp), %rdi
callq 0x250a0
jmp 0x23259
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/server/players.cpp
// Function: (anonymous namespace)::equal_ip(sockaddr_storage const*, sockaddr_storage const*)
bool equal_ip(const sockaddr_storage *first, const sockaddr_storage *second)
{
	if(first->ss_family == second->ss_family)
	{
		if(first->ss_family == AF_INET)
			return !memcmp(&(((const sockaddr_in*)first)->sin_addr),
				&(((const sockaddr_in*)second)->sin_addr), sizeof(in_addr));
		// else address family is AF_INET6
		return !memcmp(&(((const sockaddr_in6*)first)->sin6_addr),
				&(((const sockaddr_in6*)second)->sin6_addr), sizeof(in6_addr));
	}
	return false; // one is IPv4, other IPv6
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x2334d
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
jne 0x23315
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x23351
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x23351
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/players.cpp
// Function: (anonymous namespace)::add_and_register_player(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, sockaddr_storage&, bool)
unsigned short add_and_register_player(const string &nick, string &passw,
	sockaddr_storage &sas, const bool is_bot)
{
	list<PlayerStats>::iterator newpl = new_player();
	register_player(nick, sas, newpl, is_bot);
	passw.assign(newpl->password);
	return newpl->ID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
callq 0x248e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5220
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
callq 0x23420
jmp 0x233b7
leaq -0x48(%rbp), %rdi
callq 0x5a48
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b390
movq -0x70(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x59c0
leaq -0x28(%rbp), %rdi
callq 0x1b390
movw (%rax), %ax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5a48
movq -0x58(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)