LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Utils.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void split(const string& str, vector<string>& tokens, const string& delimiters) {
	// Skip delimiters at beginning.
	string::size_type lastPos = str.find_first_not_of(delimiters, 0);
	// Find first "non-delimiter".
	string::size_type pos = str.find_first_of(delimiters, lastPos);

	while (string::npos != pos || string::npos != lastPos)
	{
		// Found a token, add it to the vector.
		tokens.push_back(str.substr(lastPos, pos - lastPos));
		// Skip delimiters.  Note the "not_of"
		lastPos = str.find_first_not_of(delimiters, pos);
		// Find next "non-delimiter"
		pos = str.find_first_of(delimiters, lastPos);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
xorl %edx, %edx
callq 0x28860
movq %rax, %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x28930
movq %rax, %r13
leaq 0x8(%rsp), %r12
movq %rbp, %rax
andq %r13, %rax
cmpq $-0x1, %rax
je 0x9ecfa
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x28a90
movq %r14, %rdi
movq %r12, %rsi
callq 0x5ec8c
movq %r12, %rdi
callq 0x295a0
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x28860
movq %rax, %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x28930
movq %rax, %r13
jmp 0x9eca3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Utils.cpp
// Function: commonPath(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, char)
string commonPath( const std::vector<std::string> & dirs , char separator ) {
	std::vector<std::string>::const_iterator vsi = dirs.begin( ) ;
	int maxCharactersCommon = vsi->length( ) ;
	std::string compareString = *vsi ;
	for ( vsi = dirs.begin( ) + 1 ; vsi != dirs.end( ) ; vsi++ ) {
		std::pair<std::string::const_iterator , std::string::const_iterator> p =
		std::mismatch( compareString.begin( ) , compareString.end( ) , vsi->begin( ) ) ;
		if (( p.first - compareString.begin( ) ) < maxCharactersCommon )
		maxCharactersCommon = p.first - compareString.begin( ) ;
	}
	std::string::size_type found = compareString.rfind( separator , maxCharactersCommon ) ;
	return compareString.substr( 0 , found ) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
movl 0x8(%rsi), %r14d
movq %rsp, %rdi
callq 0x28dd0
movq (%r15), %r12
addq $0x20, %r12
movslq %r14d, %r14
cmpq 0x8(%r15), %r12
je 0x9f339
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq %rdi, %rsi
movq (%r12), %rdx
callq 0x9ff5c
subq (%rsp), %rax
cmpq %r14, %rax
cmovll %eax, %r14d
jmp 0x9f30a
movsbl %bpl, %esi
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x294f0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x28a90
movq %rsp, %rdi
callq 0x295a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f375
movq %rax, %rbx
movq %rsp, %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Utils.cpp
// Function: createParticlePipe(char const*)
bool createParticlePipe(const char * path) {

	if (checkIfFileExists(path)) {
		unlink(path);
	}

	int fifo_status = mkfifo(path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
	if (fifo_status) {
		cout << "Warning: Couldn't create pipe with path: " << path << endl;
		return false;
	}
	else {
		return true;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33402
movq %r14, %rdi
callq 0x9ec28
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x295a0
testl %ebp, %ebp
je 0x9f3c8
movq %rbx, %rdi
callq 0x28480
movq %rbx, %rdi
movl $0x1b0, %esi            # imm = 0x1B0
callq 0x28150
movl %eax, %ebp
testl %eax, %eax
je 0x9f401
movq 0xc6bb6(%rip), %rdi     # 0x165f98
leaq 0x60ff2(%rip), %rsi     # 0x1003db
callq 0x289f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x289f0
movq %rax, %rdi
callq 0x284a0
testl %ebp, %ebp
sete %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Utils.cpp
// Function: isFloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isFloat(string number) {
	istringstream iss(number);
	float f;
	iss >> noskipws >> f; // noskipws considers leading whitespace invalid
	// Check the entire string was consumed and if either failbit or badbit is set
	return iss.eof() && !iss.fail();
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x291e0
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x28(%rsp,%rax) # imm = 0xFFFFEFFF
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x29550
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
sete %bl
callq 0x28460
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x28460
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Utils.cpp
// Function: runCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int runCommand(string cmd, string &result) {

	std::shared_ptr<FILE> pipe(popen(cmd.c_str(), "r"), pclose);

	if (!pipe) {
		return 1;
	}

	char buffer[1024];
	result.clear();

	while (!feof(pipe.get())) {
		if (fgets(buffer, 1024, pipe.get()) != NULL)
			result += buffer;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, %rbx
movq (%rdi), %rdi
leaq 0x3ac8c(%rip), %rsi     # 0xda13c
callq 0x282f0
movq 0xc6b04(%rip), %rdx     # 0x165fc0
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x9ff88
cmpq $0x0, (%r14)
je 0x9f514
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %r14
movq (%rsp), %rdi
callq 0x29030
testl %eax, %eax
jne 0x9f510
movq (%rsp), %rdx
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x29070
testq %rax, %rax
je 0x9f4e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29480
jmp 0x9f4e0
xorl %ebx, %ebx
jmp 0x9f517
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %rdi
callq 0x9f738
movl %ebx, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9f738
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/ordered_dither.cpp
// Function: main
int main(int argc, char** argv) {
    int n, m;
    double gamma;
    imageP	I1, I2, tmp_img;
    // read input image (I1) and reserve space for output (I2)
    I1 = IP_readImage(argv[1]);
    I2 = NEWIMAGE;
    tmp_img = NEWIMAGE;
    
    // read m and gamma from STDIN
    m = atoi(argv[2]);
    n = pow(m, 2);

    // check if n is a power of 2
    if (n != 9) {
        if (not(is_pow_of_2(n))) {
            cerr << n << " is not a power of 2. Exiting." << endl;
            exit(1);
        }
    }
    gamma = atof(argv[3]);
    
    // threshold image and save result in file
    ordered_dither(I1, n, gamma, I2, tmp_img, m);
    IP_saveImage(I2, argv[4]);
    
    // free up image structures/memory
    IP_freeImage(I1);
    IP_freeImage(I2);
    IP_freeImage(tmp_img);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x1614
movq %rax, %rbx
pushq $0x10
popq %r12
movq %r12, %rdi
callq 0x1100
movq %rax, %r15
movq %r12, %rdi
callq 0x1100
movq %rax, %r12
movq 0x10(%r14), %rdi
callq 0x1140
movl %eax, %ebp
cvtsi2sd %eax, %xmm0
mulsd %xmm0, %xmm0
cvttsd2si %xmm0, %r13d
cmpl $0x9, %r13d
je 0x133c
testl %r13d, %r13d
je 0x1393
leal -0x1(%r13), %eax
testl %eax, %r13d
jne 0x1393
movq 0x18(%r14), %rdi
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq 0x13d1
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x17de
movq %rbx, %rdi
callq 0x18df
movq %r15, %rdi
callq 0x18df
movq %r12, %rdi
callq 0x18df
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2c56(%rip), %rdi      # 0x3ff0
movl %r13d, %esi
callq 0x1150
leaq 0xc6f(%rip), %rsi       # 0x2018
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/input_event_names.h
// Function: evout(input_event const&)
void evout(const input_event &e){
   if (e.type == EV_KEY){
       fprintf(stdout,"EV_KEY(%s:%d, %s:%d)\n",
              key_code_name(e.code), e.code,
              key_state_name(e.value), e.value);
   }else if (e.type == EV_MSC){
       fprintf(stdout,"EV_MSC(%s:%d, %d)\n",
              msc_code_name(e.code), e.code,
              e.value);
   }else if (e.type == EV_SYN){
       fprintf(stdout,"EV_SYN~%s:%d\n",
              syn_code_name(e.code),e.value);
   }
   else{
       fprintf(stderr,"%s\n", ev_code_name(e.type));
   }
}

// Assembly:
movzwl 0x10(%rdi), %eax
testl %eax, %eax
je 0x343c
cmpl $0x4, %eax
je 0x345d
cmpl $0x1, %eax
jne 0x34cd
movq 0x3bb9(%rip), %rax      # 0x6fb8
movzwl 0x12(%rdi), %ecx
cmpl $0xf8, %ecx
leaq 0x3d90(%rip), %rdx      # 0x71a0
leaq (%rdx,%rcx,8), %rdx
leaq 0x3d7d(%rip), %rsi      # 0x7198
cmovbq %rdx, %rsi
movq (%rax), %rax
movq (%rsi), %rdx
movl 0x14(%rdi), %r9d
cmpq $0x2, %r9
ja 0x347e
leaq 0x396a(%rip), %rsi      # 0x6da0
movq (%rsi,%r9,8), %r8
jmp 0x3485
movq 0x3b75(%rip), %rax      # 0x6fb8
movq (%rax), %rax
movzwl 0x12(%rdi), %ecx
cmpq $0x3, %rcx
ja 0x3496
leaq 0x3d19(%rip), %rdx      # 0x7170
movq (%rdx,%rcx,8), %rdx
jmp 0x349d
movq 0x3b54(%rip), %rax      # 0x6fb8
movq (%rax), %rax
movzwl 0x12(%rdi), %ecx
cmpq $0x6, %rcx
ja 0x34b1
leaq 0x44e8(%rip), %rdx      # 0x7960
movq (%rdx,%rcx,8), %rdx
jmp 0x34b8
leaq 0x1688(%rip), %r8       # 0x4b0d
leaq 0x16a0(%rip), %rsi      # 0x4b2c
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
leaq 0x1683(%rip), %rdx      # 0x4b20
movl 0x14(%rdi), %ecx
leaq 0x16ae(%rip), %rsi      # 0x4b55
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
leaq 0x165c(%rip), %rdx      # 0x4b14
movl 0x14(%rdi), %r8d
leaq 0x167f(%rip), %rsi      # 0x4b42
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
movq 0x3b1c(%rip), %rcx      # 0x6ff0
movq (%rcx), %rdi
cmpw $0x6, %ax
leaq 0x3c5e(%rip), %rcx      # 0x7140
leaq (%rcx,%rax,8), %rax
leaq 0x3ca3(%rip), %rcx      # 0x7190
cmovbq %rax, %rcx
movq (%rcx), %rdx
leaq 0x170c(%rip), %rsi      # 0x4c07
xorl %eax, %eax
jmp 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: is_keyboard(int)
int is_keyboard(int fd) {
    errno = 0;
    u_int64_t evbitset = 0;
    u_int64_t keybits[4] = {0};
    ioctl(fd, EVIOCGBIT(0, sizeof(evbitset)), &evbitset);
    if (errno) return 0;
    if (!(evbitset & (1ul << EV_KEY))) {
        return 0;
    }

    errno = 0;
    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
    if (errno)
        return 0;

    if (keybits[0] | keybits[1] | keybits[2] | keybits[3]) {
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebp
movl $0x80084520, %r15d      # imm = 0x80084520
callq 0x3050
movq %rax, %r14
andl $0x0, (%rax)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x20(%rsp)
movdqa %xmm0, 0x10(%rsp)
xorl %ebx, %ebx
movl $0x80084520, %esi       # imm = 0x80084520
movl %ebp, %edi
xorl %eax, %eax
callq 0x30f0
cmpl $0x0, (%r14)
jne 0x3598
testb $0x2, 0x8(%rsp)
je 0x3598
andl $0x0, (%r14)
addq $0x180001, %r15         # imm = 0x180001
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdx
movl %ebp, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x30f0
cmpl $0x0, (%r14)
jne 0x3598
movdqa 0x10(%rsp), %xmm0
por 0x20(%rsp), %xmm0
pxor %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %eax
xorl %ebx, %ebx
xorl $0xf, %eax
setne %bl
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: find_keyboard_in(KeyboardList&, char const*)
void find_keyboard_in(KeyboardList &keyboards, const char * path) {
    DIR *d;
    struct dirent *dir;
    struct Keyboard inputs[32] = {0}; //12 Slots
    int inputs_len = 0;
    char buf[1024]; //12 Slots
    d = opendir(path);
    if (d) {
        while ((dir = readdir(d)) != NULL) {
            if (kbd_suffix(dir->d_name)) {
                if (snprintf(buf,1024,"%s%s",path, dir->d_name) > 1023) {
                    continue;
                }
                char *input = realpath(buf, NULL);
                if (input == NULL) continue;
                if (input[11] == 'e') {
                    int event_number = atoi(input + 16);
                    if (!keyboards.contains_event_number(event_number)) {
                        int fd = open(input, O_RDONLY);
                        if (!is_keyboard(fd)){
                            close(fd);
                        } else {
                            unsigned int key_repeat[2] = {2048,2048};
                            ioctl(fd, EVIOCSREP, &key_repeat); //Disable Local Simulated Key repeat
                            keyboards.append(event_number, fd, strdup(buf));
                        }
                    }
                }
                free(input);
            }
        }
        closedir(d);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x3080
testq %rax, %rax
je 0x3706
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r12, (%rsp)
movq %r15, %rdi
callq 0x31a0
testq %rax, %rax
je 0x36fe
movq %rax, %r14
addq $0x13, %r14
movq %r14, %rdi
callq 0x35a5
testl %eax, %eax
je 0x3609
movl $0x400, %esi            # imm = 0x400
movq %r13, %rdi
leaq 0x152b(%rip), %rdx      # 0x4b67
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x30c0
cmpl $0x3ff, %eax            # imm = 0x3FF
jg 0x3609
movq %r13, %rdi
xorl %esi, %esi
callq 0x3180
testq %rax, %rax
je 0x3609
movq %rax, %rbp
cmpb $0x65, 0xb(%rax)
jne 0x36f1
movq %rbp, %rdi
addq $0x10, %rdi
callq 0x3200
movl %eax, %r14d
movq %r12, %rdi
movl %eax, %esi
callq 0x3c38
testb %al, %al
jne 0x36f1
movq %rbp, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x31d0
movl %eax, %r12d
movl %eax, %edi
callq 0x3502
testl %eax, %eax
je 0x36e5
movabsq $0x80000000800, %rax    # imm = 0x80000000800
movq %rax, 0x8(%rsp)
movl $0x40084503, %esi       # imm = 0x40084503
movl %r12d, %edi
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x30f0
movq %r13, %rdi
callq 0x3220
movq (%rsp), %rdi
movl %r14d, %esi
movl %r12d, %edx
movq %rdi, %r12
movq %rax, %rcx
callq 0x3c6a
jmp 0x36f1
movl %r12d, %edi
callq 0x3100
movq (%rsp), %r12
movq %rbp, %rdi
callq 0x3030
jmp 0x3609
movq %r15, %rdi
callq 0x3110
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: print_mods(xkb_state*)
void print_mods(xkb_state * state) {
    struct {const char *name; const char *label;} mods[] = {
    {XKB_MOD_NAME_LOGO, "SUPER"},
    {XKB_MOD_NAME_ALT, "ALT"},
    {XKB_MOD_NAME_SHIFT, "SHIFT"},
    {XKB_MOD_NAME_CTRL, "CONTROL"},
    };
    int found = 0;
    for (auto & mod: mods) {
        if (xkb_state_mod_name_is_active(state, mod.name,
                                         XKB_STATE_MODS_EFFECTIVE) > 0) {
            if (found == 0) {
                printf("   XKB MODS: ");
            } else {
                printf(" ");
            }
            found++;
            printf("%s", mod.label);
        }
    }
    if (found > 0) {
        printf(";\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3633(%rip), %r13      # 0x6d60
pushq $0x8
popq %rbp
leaq 0x1432(%rip), %r15      # 0x4b69
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpq $0x40, %r12
je 0x378a
movq (%r12,%r13), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x30b0
testl %eax, %eax
jle 0x3784
testl %r14d, %r14d
je 0x3764
pushq $0x20
popq %rdi
callq 0x3040
jmp 0x3772
leaq 0x1427(%rip), %rdi      # 0x4b92
xorl %eax, %eax
callq 0x30a0
incl %r14d
movq 0x8(%r12,%r13), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x30a0
addq $0x10, %r12
jmp 0x373d
testl %r14d, %r14d
jle 0x37a9
leaq 0x1774(%rip), %rdi      # 0x4f0a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3060
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: read_events(xkb_keymap*, xkb_state*, Keyboard*)
void read_events(xkb_keymap *keymap,xkb_state *state, Keyboard *input) {
    struct input_event buf[16];
    errno = 0;
    int rd = read(input->fd, buf, sizeof(buf));
    struct input_event *end = buf + (rd / sizeof(struct input_event));
    int after_scancode = 0;
    for(const struct input_event *curr = buf; curr < end; curr++){
        if (curr->type != EV_KEY || curr->value == V_KEY_REPEAT) continue;
        xkb_keycode_t keycode;
        xkb_keysym_t keysym;
        keycode = curr->code + 8;
        keysym = xkb_state_key_get_one_sym(state, keycode);
        char keysym_name[64];
        xkb_keysym_get_name(keysym, keysym_name, sizeof(keysym_name));
        const char * keyname = xkb_keymap_key_get_name(keymap, keycode);
        printf("[%s]{\n",input->name);
        printf("   EVDEV: keycode:%d name:%s;\n", curr->code, key_code_name(curr->code));
        print_mods(state);
        printf("   XKB: key[%d]:<%s> keysym:%s;\n",
               keycode, keyname,keysym_name);
        if (curr->value == V_KEY_DOWN)
            xkb_state_update_key(state, keycode, XKB_KEY_DOWN);
        else if (curr->value == V_KEY_UP)
            xkb_state_update_key(state, keycode, XKB_KEY_UP);
        printf("}\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
callq 0x3050
andl $0x0, (%rax)
movq %rbx, 0x8(%rsp)
movl 0x4(%rbx), %edi
leaq 0x50(%rsp), %r12
movl $0x180, %edx            # imm = 0x180
movq %r12, %rsi
callq 0x3130
cltq
pushq $0x18
popq %rcx
xorl %edx, %edx
divq %rcx
imulq $0x18, %rax, %rax
leaq (%rsp,%rax), %rbx
addq $0x50, %rbx
leaq 0x10(%rsp), %r13
cmpq %rbx, %r12
jae 0x38f1
cmpw $0x1, 0x10(%r12)
jne 0x38e8
cmpl $0x2, 0x14(%r12)
je 0x38e8
movzwl 0x12(%r12), %ebp
addl $0x8, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x30d0
movl %eax, %edi
movq %r13, %rsi
pushq $0x40
popq %rdx
callq 0x3070
movq (%rsp), %rdi
movl %ebp, %esi
callq 0x31b0
movq %rax, %r15
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x1330(%rip), %rdi      # 0x4ba0
xorl %eax, %eax
callq 0x30a0
movzwl 0x12(%r12), %esi
cmpl $0xf8, %esi
leaq 0x3916(%rip), %rax      # 0x71a0
leaq (%rax,%rsi,8), %rax
leaq 0x3903(%rip), %rcx      # 0x7198
cmovaeq %rcx, %rax
movq (%rax), %rdx
leaq 0x1304(%rip), %rdi      # 0x4ba7
xorl %eax, %eax
callq 0x30a0
movq %r14, %rdi
callq 0x3718
leaq 0x130d(%rip), %rdi      # 0x4bc6
movl %ebp, %esi
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x30a0
movl 0x14(%r12), %edx
cmpl $0x1, %edx
ja 0x38dc
movq %r14, %rdi
movl %ebp, %esi
callq 0x3190
leaq 0x1629(%rip), %rdi      # 0x4f0c
callq 0x3060
addq $0x18, %r12
jmp 0x3810
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: parse_arguments(Settings&&, int, char**)
Settings parse_arguments(Settings &&setting, int argc, char **argv){
    opterr = 0;
    optind = 0;
    char *cvalue = NULL;
    int c;
    while ((c = getopt (argc, argv, "hr:m:l:v:o:k")) != -1)
        switch(c){
            case 'h':
                print_usage();
                exit(0);
            case 'l':
                setting.xkb_names.layout = optarg;
                continue;
            case 'm':
                setting.xkb_names.model = optarg;
                continue;
            case 'r':
                setting.xkb_names.rules = optarg;
                continue;
            case 'o':
                setting.xkb_names.options = optarg;
                continue;
            case 'v':
                setting.xkb_names.variant = optarg;
                continue;
            case 'k':
                setting.only_print = true;
                continue;
        }
    return setting;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq 0x352c(%rip), %rax      # 0x6fe8
andl $0x0, (%rax)
movq 0x34fa(%rip), %rax      # 0x6fc0
andl $0x0, (%rax)
movq %rdi, (%rsp)
leaq 0x13db(%rip), %r12      # 0x4eaf
leaq 0x529(%rip), %r13       # 0x4004
movq 0x34e6(%rip), %r15      # 0x6fc8
movl %ebp, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x31f0
leal -0x68(%rax), %ecx
cmpl $0xe, %ecx
ja 0x3b33
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movb $0x1, 0x28(%rbx)
jmp 0x3ae2
movq (%r15), %rax
movq %rax, (%rbx)
jmp 0x3ae2
movq (%r15), %rax
movq %rax, 0x10(%rbx)
jmp 0x3ae2
movq (%r15), %rax
movq %rax, 0x20(%rbx)
jmp 0x3ae2
movq (%r15), %rax
movq %rax, 0x8(%rbx)
jmp 0x3ae2
movq (%r15), %rax
movq %rax, 0x18(%rbx)
jmp 0x3ae2
cmpl $-0x1, %eax
jne 0x3ae2
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movq (%rsp), %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3a96
xorl %edi, %edi
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: main
int main(int argc, char *argv[]) {
    Settings settings = parse_arguments(Settings(), argc, argv);
    KeyboardList keyboards;
    find_keyboard_in(keyboards, "/dev/input/by-id/");
    find_keyboard_in(keyboards, "/dev/input/by-path/");
    if(settings.only_print) {
        keyboards.print();
        exit(1);
    }
    printf("Found %d Possible Keyboards.\n---\n", keyboards.len);
    keyboards.print();
    printf("---\n");
    if (poll_keyboard_events(settings, keyboards)) {
        perror("ERROR");
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %rcx
movl %edi, %edx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3aa2
andl $0x0, 0x200(%rbx)
leaq 0x1311(%rip), %rsi      # 0x4ebc
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x35d5
leaq 0x130f(%rip), %rsi      # 0x4ece
movq %rbx, %rdi
callq 0x35d5
cmpb $0x1, 0x28(%r14)
je 0x3c25
leaq 0x30(%rsp), %rbx
movl 0x200(%rbx), %esi
leaq 0x1302(%rip), %rdi      # 0x4ee2
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rdi
callq 0x3c96
leaq 0x1318(%rip), %rdi      # 0x4f0e
callq 0x3060
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3903
testl %eax, %eax
jne 0x3c17
xorl %eax, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
leaq 0x12e6(%rip), %rdi      # 0x4f04
callq 0x31e0
jmp 0x3c0a
leaq 0x30(%rsp), %rdi
callq 0x3c96
pushq $0x1
popq %rdi
callq 0x3210
nop
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: KeyboardList::contains_event_number(int)
bool contains_event_number(int event_number) {
        for(int i = 0; i < len; i++) {
            if (keyboards[i].event_number == event_number)
                return true;
        }
        return false;
    }

// Assembly:
movslq 0x200(%rdi), %rax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movq %rdx, %r8
cmpq %rdx, %rcx
je 0x3c62
leaq 0x1(%r8), %rdx
leaq 0x10(%rdi), %r9
cmpl %esi, (%rdi)
movq %r9, %rdi
jne 0x3c4b
cmpq %rax, %r8
setl %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/exrok[P]evdoublebind/./src/inspector.cc
// Function: KeyboardList::append(int, int, char*)
void append(int event_number, int fd, char*name) {
        if (len >= 32) return;
        keyboards[len].event_number = event_number;
        keyboards[len].fd = fd;
        keyboards[len].name = name;
        len++;
    }

// Assembly:
movslq 0x200(%rdi), %rax
cmpq $0x1f, %rax
jg 0x3c94
movq %rax, %r8
shlq $0x4, %r8
movl %esi, (%rdi,%r8)
movl %edx, 0x4(%rdi,%r8)
movq %rcx, 0x8(%rdi,%r8)
incl %eax
movl %eax, 0x200(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/main.cpp
// Function: help()
void help() {
    cout << gsw_info::H_COMMON << endl;
    cout << "Options:" << endl;
    cout << gsw_info::H_VERSION << endl;
    cout << gsw_info::H_HELP << endl;
    cout << gsw_info::H_CURRENT << endl;
    cout << gsw_info::H_LIST << endl;
    cout << gsw_info::H_ADD << endl;
    cout << gsw_info::H_UPDATE << endl;
    cout << gsw_info::H_SWAP << endl;
    cout << gsw_info::H_REMOVE << endl;
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x4c9d(%rip), %rbx      # 0x7fc0
leaq 0x4f1e(%rip), %rsi      # 0x8248
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x206a(%rip), %rsi      # 0x53ab
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
leaq 0x4f10(%rip), %rsi      # 0x8268
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4f19(%rip), %rsi      # 0x8288
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4f22(%rip), %rsi      # 0x82a8
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4f2b(%rip), %rsi      # 0x82c8
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4f34(%rip), %rsi      # 0x82e8
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4f3d(%rip), %rsi      # 0x8308
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4f46(%rip), %rsi      # 0x8328
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4f4f(%rip), %rsi      # 0x8348
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/main.cpp
// Function: add(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>> const&)
void add(const string& name, const string& email) {
    if (name.empty() || email.empty()) {
        cout << EMPTY_NAME_EMAIL_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    Profile profile(name, email);
    Store store;
    store.append(profile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
cmpq $0x0, 0x8(%rdi)
je 0x34a4
movq %rsi, %rdx
cmpq $0x0, 0x8(%rsi)
je 0x34a4
movq %rdi, %rsi
leaq -0x48(%rbp), %rdi
callq 0x42d4
leaq -0x278(%rbp), %rdi
callq 0x4408
leaq -0x278(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x461c
leaq -0x278(%rbp), %rdi
callq 0x470c
leaq -0x48(%rbp), %rdi
callq 0x3b48
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %rbp
retq
movq 0x4b15(%rip), %rbx      # 0x7fc0
leaq 0x4f76(%rip), %rsi      # 0x8428
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4e9f(%rip), %rsi      # 0x8368
movq %rbx, %rdi
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %rbp
jmp 0x21b0
movq %rax, %rbx
leaq -0x278(%rbp), %rdi
callq 0x470c
jmp 0x34ee
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3b48
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/main.cpp
// Function: update(int, 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>> const&)
void update(int number, const string& name, const string& email) {
    if (name.empty() || email.empty()) {
        cout << EMPTY_NAME_EMAIL_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    Store store;
    if (number <= 0 || number > store.size()) {
        cout << NONEXISTENT_INDEX_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    Profile profile(name, email);
    store.update(number - 1, profile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
cmpq $0x0, 0x8(%rsi)
je 0x3575
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x3575
movq %rsi, %r15
movl %edi, %ebx
leaq -0x288(%rbp), %rdi
callq 0x4408
testl %ebx, %ebx
jle 0x3545
leaq -0x288(%rbp), %rdi
callq 0x46f4
cmpl %ebx, %eax
jge 0x35af
movq 0x4a74(%rip), %rdi      # 0x7fc0
leaq 0x4eb5(%rip), %rsi      # 0x8408
callq 0x21b0
movq %rax, %rdi
callq 0x2100
movq 0x4a59(%rip), %rdi      # 0x7fc0
leaq 0x4dfa(%rip), %rsi      # 0x8368
callq 0x21b0
jmp 0x35db
movq 0x4a44(%rip), %rbx      # 0x7fc0
leaq 0x4ea5(%rip), %rsi      # 0x8428
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
leaq 0x4dce(%rip), %rsi      # 0x8368
movq %rbx, %rdi
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x42d4
decl %ebx
leaq -0x288(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movl %ebx, %esi
callq 0x4662
leaq -0x58(%rbp), %rdi
callq 0x3b48
leaq -0x288(%rbp), %rdi
callq 0x470c
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3b48
jmp 0x3608
jmp 0x3605
movq %rax, %rbx
leaq -0x288(%rbp), %rdi
callq 0x470c
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/main.cpp
// Function: swap(int)
void swap(int number) {
    Store store;
    if (number <= 0 || number > store.size()) {
        cout << NONEXISTENT_INDEX_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    Profile chosen = store.get(number - 1);
    string swapName(SWAP_NAME_GIT_CMD + QUOTE + chosen.getName() + QUOTE);
    string swapEmail(SWAP_EMAIL_GIT_CMD + QUOTE + chosen.getEmail() + QUOTE);
    system(swapName.c_str());
    system(swapEmail.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x2f8, %rsp            # imm = 0x2F8
movl %edi, %ebx
leaq -0x2f8(%rbp), %rdi
callq 0x4408
testl %ebx, %ebx
jle 0x364a
leaq -0x2f8(%rbp), %rdi
callq 0x46f4
cmpl %ebx, %eax
jge 0x367d
movq 0x496f(%rip), %rdi      # 0x7fc0
leaq 0x4db0(%rip), %rsi      # 0x8408
callq 0x21b0
movq %rax, %rdi
callq 0x2100
movq 0x4954(%rip), %rdi      # 0x7fc0
leaq 0x4cf5(%rip), %rsi      # 0x8368
callq 0x21b0
jmp 0x3787
decl %ebx
leaq -0x2f8(%rbp), %rdi
movl %ebx, %esi
callq 0x4640
leaq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x3b68
leaq 0x4dc5(%rip), %rsi      # 0x8468
leaq 0x4dfe(%rip), %rdx      # 0x84a8
leaq -0x28(%rbp), %rdi
callq 0x3bcb
leaq -0xc8(%rbp), %rdi
callq 0x4358
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x3ba2
leaq 0x4dd2(%rip), %rdx      # 0x84a8
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3ba2
leaq -0x48(%rbp), %rdi
callq 0x2378
leaq -0x28(%rbp), %rdi
callq 0x2378
leaq 0x4d89(%rip), %rsi      # 0x8488
leaq 0x4da2(%rip), %rdx      # 0x84a8
leaq -0x68(%rbp), %rdi
callq 0x3bcb
leaq -0xc8(%rbp), %rdi
callq 0x4362
leaq -0x28(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x3ba2
leaq 0x4d76(%rip), %rdx      # 0x84a8
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3ba2
leaq -0x28(%rbp), %rdi
callq 0x2378
leaq -0x68(%rbp), %rdi
callq 0x2378
movq -0x88(%rbp), %rdi
callq 0x2190
movq -0x48(%rbp), %rdi
callq 0x2190
leaq -0x48(%rbp), %rdi
callq 0x2378
leaq -0x88(%rbp), %rdi
callq 0x2378
leaq -0xc8(%rbp), %rdi
callq 0x3b48
leaq -0x2f8(%rbp), %rdi
callq 0x470c
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2378
jmp 0x37cf
movq %rax, %rbx
jmp 0x37d8
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2378
jmp 0x37e4
movq %rax, %rbx
jmp 0x37ed
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0x37d3
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2378
leaq -0x88(%rbp), %rdi
jmp 0x37e8
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2378
leaq -0xc8(%rbp), %rdi
callq 0x3b48
jmp 0x3800
jmp 0x37fd
movq %rax, %rbx
leaq -0x2f8(%rbp), %rdi
callq 0x470c
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/main.cpp
// Function: remove(int)
void remove(int number) {
    Store store;
    if (number <= 0 || number > store.size()) {
        cout << NONEXISTENT_INDEX_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    store.remove(number - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl %edi, %ebx
leaq -0x238(%rbp), %rdi
callq 0x4408
testl %ebx, %ebx
jle 0x3842
leaq -0x238(%rbp), %rdi
callq 0x46f4
cmpl %ebx, %eax
jge 0x3872
movq 0x4777(%rip), %rdi      # 0x7fc0
leaq 0x4bb8(%rip), %rsi      # 0x8408
callq 0x21b0
movq %rax, %rdi
callq 0x2100
movq 0x475c(%rip), %rdi      # 0x7fc0
leaq 0x4afd(%rip), %rsi      # 0x8368
callq 0x21b0
jmp 0x3882
decl %ebx
leaq -0x238(%rbp), %rdi
movl %ebx, %esi
callq 0x46c2
leaq -0x238(%rbp), %rdi
callq 0x470c
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x470c
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/main.cpp
// Function: list()
void list() {
    Store store;
    int size = store.size();
    vector<Profile> profileList = store.getAll();
    for (int i = 0; i < size; i++) {
        cout << left;
        cout << setw(NUMBER_WIDTH) << i + 1;
        cout << setw(NAME_WIDTH) << profileList[i].getName();
        cout << setw(EMAIL_WIDTH) << profileList[i].getEmail();
        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
leaq -0x270(%rbp), %rbx
movq %rbx, %rdi
callq 0x4408
movq %rbx, %rdi
callq 0x46f4
movl %eax, %ebx
leaq -0x270(%rbp), %rdi
callq 0x4654
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3ac8
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
shlq $0x6, %rbx
pushq $0x1
popq %r14
movq 0x46b4(%rip), %r15      # 0x7fc0
movl $0xffffff4f, %r13d      # imm = 0xFFFFFF4F
cmpq %r12, %rbx
je 0x39ac
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r15,%rcx), %edx
andl %r13d, %edx
orl $0x20, %edx
movl %edx, 0x18(%r15,%rcx)
movq -0x18(%rax), %rax
movq $0x4, 0x10(%r15,%rax)
movq %r15, %rdi
movl %r14d, %esi
callq 0x2300
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x30, 0x10(%r15,%rax)
movq -0x40(%rbp), %rdi
addq %r12, %rdi
callq 0x4358
movq %r15, %rdi
movq %rax, %rsi
callq 0x21b0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x30, 0x10(%r15,%rax)
movq -0x40(%rbp), %rdi
addq %r12, %rdi
callq 0x4362
movq %r15, %rdi
movq %rax, %rsi
callq 0x21b0
addq $0x40, %r12
incl %r14d
movq %r15, %rdi
callq 0x2100
jmp 0x3912
leaq -0x40(%rbp), %rdi
callq 0x3b1c
leaq -0x270(%rbp), %rdi
callq 0x470c
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39d5
movq %rax, %rbx
jmp 0x39e6
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3b1c
leaq -0x270(%rbp), %rdi
callq 0x470c
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/Options/Options.cpp
// Function: Options::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const string& Options::get(const string &option) {
    vector<string>::const_iterator itr;
    itr = find(this->tokens.begin(), this->tokens.end(), option);
    if (itr != this->tokens.end() && ++itr != this->tokens.end()){
        return *itr;
    }
    static const string empty_string("");
    return empty_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0x41a8
movq %rax, %rbx
movq 0x8(%r14), %rax
cmpq %rax, %rbx
setne %cl
addq $0x20, %rbx
cmpq %rax, %rbx
setne %al
testb %al, %cl
jne 0x3f33
movb 0x45c0(%rip), %al       # 0x84e8
leaq 0x4599(%rip), %rbx      # 0x84c8
testb %al, %al
je 0x3f3f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x45a2(%rip), %rdi      # 0x84e8
callq 0x2320
testl %eax, %eax
je 0x3f33
leaq 0x4572(%rip), %rbx      # 0x84c8
leaq 0x13a2(%rip), %rsi      # 0x52ff
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
callq 0x20b0
movq 0x4040(%rip), %rdi      # 0x7fb0
leaq 0x4249(%rip), %rdx      # 0x81c0
movq %rbx, %rsi
callq 0x21a0
leaq 0x4562(%rip), %rdi      # 0x84e8
callq 0x2160
jmp 0x3f33
movq %rax, %rbx
leaq 0x4551(%rip), %rdi      # 0x84e8
callq 0x2150
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/Store/Store.cpp
// Function: Store::Store()
Store::Store() {
    store.open(STORE_LOCATION + STORE_NAME, ios::in);
    if (store.is_open()) {
        string profileString;
        string name;
        string email;
        while (getline(store, profileString)) {
            istringstream profileStream(profileString);
            getline(profileStream, name, Profile::SEPARATOR);
            getline(profileStream, email, Profile::SEPARATOR);
            Profile loadedProfile(name, email);
            allProfiles.push_back(loadedProfile);
        }
    } else {
        store.clear();
    }
    store.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
callq 0x2210
leaq 0x210(%rbx), %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x219(%rbx)
movups %xmm0, 0x210(%rbx)
leaq 0x40a9(%rip), %rsi      # 0x84f0
leaq 0x40c2(%rip), %rdx      # 0x8510
leaq -0x258(%rbp), %rdi
callq 0x3bcb
leaq -0x258(%rbp), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x2260
leaq -0x258(%rbp), %rdi
callq 0x2378
leaq 0x80(%rbx), %rdi
callq 0x2080
testb %al, %al
je 0x4551
movq %rbx, -0x30(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq -0x88(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %dl, (%rax)
leaq -0x258(%rbp), %r12
leaq -0x98(%rbp), %r14
pushq $0x3b
popq %r13
leaq -0x78(%rbp), %rbx
leaq -0xd8(%rbp), %r15
movq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4564
movq %r12, %rdi
leaq -0x58(%rbp), %rsi
pushq $0x8
popq %rdx
callq 0x22d0
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x2330
movq %r12, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x2330
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x42d4
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x484a
movq %r15, %rdi
callq 0x3b48
movq %r12, %rdi
callq 0x20f0
jmp 0x44df
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x22e0
jmp 0x4586
leaq -0x78(%rbp), %rdi
callq 0x2378
leaq -0x98(%rbp), %rdi
callq 0x2378
leaq -0x58(%rbp), %rdi
callq 0x2378
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2040
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, -0x30(%rbp)
movq %rax, %r15
leaq -0x258(%rbp), %rdi
jmp 0x45fd
jmp 0x45b2
movq %rbx, -0x30(%rbp)
movq %rax, %r15
jmp 0x4602
movq %rax, %r15
leaq -0xd8(%rbp), %rdi
callq 0x3b48
jmp 0x45d8
jmp 0x45d5
jmp 0x45d0
movq %rax, %r15
jmp 0x45e4
movq %rax, %r15
leaq -0x258(%rbp), %rdi
callq 0x20f0
leaq -0x78(%rbp), %rdi
callq 0x2378
leaq -0x98(%rbp), %rdi
callq 0x2378
leaq -0x58(%rbp), %rdi
callq 0x2378
movq -0x38(%rbp), %rdi
callq 0x3b1c
movq -0x30(%rbp), %rdi
callq 0x2070
movq %r15, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/XDragonSl[P]git-switcher/src/Store/Store.cpp
// Function: Store::~Store()
Store::~Store() {
    if (isChanged) {
        store.open(STORE_LOCATION + STORE_NAME, ios::out);
        for(Profile profile : allProfiles) {
            store << profile.toString() << endl;
        }
        store.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x228(%rdi)
jne 0x47d2
movq %rbx, -0x30(%rbp)
leaq 0x3db8(%rip), %rsi      # 0x84f0
leaq 0x3dd1(%rip), %rdx      # 0x8510
leaq -0x70(%rbp), %rdi
callq 0x3bcb
leaq -0x70(%rbp), %rsi
pushq $0x10
popq %rdx
movq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x2260
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x2378
movq 0x210(%r12), %r15
movq 0x218(%r12), %rbx
addq $0x10, %r12
leaq -0x90(%rbp), %r13
cmpq %rbx, %r15
je 0x47c6
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b68
movq %r13, %rdi
movq %r14, %rsi
callq 0x436c
movq %r12, %rdi
movq %r13, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
movq %r13, %rdi
callq 0x2378
movq %r14, %rdi
callq 0x3b48
addq $0x40, %r15
jmp 0x4782
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2040
leaq 0x210(%rbx), %rdi
callq 0x3b1c
movq %rbx, %rdi
callq 0x2070
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4807
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x2378
jmp 0x4829
jmp 0x4807
movq %rax, %r14
jmp 0x4829
movq %rax, %r14
jmp 0x4820
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0x2378
leaq -0x70(%rbp), %rdi
callq 0x3b48
movq -0x30(%rbp), %rbx
leaq 0x210(%rbx), %rdi
callq 0x3b1c
movq %rbx, %rdi
callq 0x2070
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/matallui[P]nibble-curses/src/CPoint.cpp
// Function: CPoint::operator=(CPoint const&)
CPoint & CPoint::operator = ( CPoint const & src )
{
  if ( &src == this ) return *this;
  
  m_x = src.getX();
  m_y = src.getY();
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
cmpq %rdi, %rsi
je 0x37c0
movl (%rsi), %ecx
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Update(int const&, int const&, int const&, char const&)
void CObstacle::Update ( int const & ox, int const & oy, int const & length, char const & mode )
{
  m_orig.setX ( ox );
  m_orig.setY ( oy );
  m_length = length;
  m_mode = mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
callq 0x37c2
movq %r12, %rdi
movq %r15, %rsi
callq 0x37cc
movl (%r14), %eax
movl %eax, 0x8(%r12)
movb (%rbx), %al
movb %al, 0xc(%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Paint() const
void CObstacle::Paint ( void ) const
{
  int x = m_orig.getX();
  int y = m_orig.getY();
  
  switch ( m_mode )
  {
    case 'V':					// draw vertical object starting on the upper point
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x+i, y );
	addch ( ' ' );
      }
      break;
    case 'H':					// draw horizontal object starting on the left
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x, y+i );
	addch ( ' ' );
      }
      break;
    case 'D':					// draw diagonal object starting on the upper-left points
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x+i, y+i );
	addch ( ' ' );
      }
      break;
    case 'I':					// draw dashed vertical object starting from upper point
      for ( int i = 0; i < m_length; i+=2 )
      {
	move ( x+i, y );
	addch ( ' ' );
      }
      break;
  }
  
  refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3798
movl %eax, %r14d
movq %rbx, %rdi
callq 0x37a0
movl %eax, %r15d
movzbl 0xc(%rbx), %eax
cmpl $0x44, %eax
je 0x39c3
cmpl $0x48, %eax
je 0x395f
cmpl $0x56, %eax
je 0x3993
cmpl $0x49, %eax
jne 0x39f4
xorl %r13d, %r13d
pushq $0x20
popq %r12
cmpl 0x8(%rbx), %r13d
jge 0x39f4
leal (%r14,%r13), %edi
movl %r15d, %esi
callq 0x31d0
movq 0x8682(%rip), %rax      # 0xbfd0
movq (%rax), %rdi
movl %r12d, %esi
callq 0x30b0
addl $0x2, %r13d
jmp 0x3931
xorl %r13d, %r13d
pushq $0x20
popq %r12
cmpl 0x8(%rbx), %r13d
jge 0x39f4
leal (%r15,%r13), %esi
movl %r14d, %edi
callq 0x31d0
movq 0x864d(%rip), %rax      # 0xbfd0
movq (%rax), %rdi
movl %r12d, %esi
callq 0x30b0
incl %r13d
jmp 0x3966
xorl %r13d, %r13d
pushq $0x20
popq %r12
cmpl 0x8(%rbx), %r13d
jge 0x39f4
leal (%r14,%r13), %edi
movl %r15d, %esi
callq 0x31d0
movq 0x861d(%rip), %rax      # 0xbfd0
movq (%rax), %rdi
movl %r12d, %esi
callq 0x30b0
incl %r13d
jmp 0x399a
xorl %r13d, %r13d
pushq $0x20
popq %r12
cmpl 0x8(%rbx), %r13d
jge 0x39f4
leal (%r14,%r13), %edi
leal (%r15,%r13), %esi
callq 0x31d0
movq 0x85ec(%rip), %rax      # 0xbfd0
movq (%rax), %rdi
movl %r12d, %esi
callq 0x30b0
incl %r13d
jmp 0x39ca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Intersection(CPoint const&) const
bool CObstacle::Intersection ( CPoint const & p ) const
{
  int px = p.getX();
  int py = p.getY();
  int ox = m_orig.getX();
  int oy = m_orig.getY();
  bool res;
  
  switch ( m_mode )
  {
    case 'V':
      res = ( (py == oy) && (px >= ox) && (px < (ox+m_length)) );
      break;
    case 'H':
      res = ( (px == ox) && (py >= oy) && (py < (oy+m_length)) );
      break;
    case 'D':
      res = ( (px >= ox) && (px < (ox+m_length)) && (py >= oy) && (py < (oy+m_length)) && ((py-px) == (oy-ox)) );
      break;
    case 'I':
      res = ( (py == oy) && (px >= ox) && (px < (ox+m_length)) && ((px%2) == (ox%2)) );
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x3798
movl %eax, %ebx
movq %r14, %rdi
callq 0x37a0
movl %eax, %r12d
movq %r15, %rdi
callq 0x3798
movl %eax, %r14d
movq %r15, %rdi
callq 0x37a0
movzbl 0xc(%r15), %ecx
cmpl $0x44, %ecx
je 0x3b05
cmpl $0x48, %ecx
je 0x3aec
cmpl $0x49, %ecx
jne 0x3b3e
cmpl %eax, %r12d
setne %al
cmpl %r14d, %ebx
setl %cl
orb %al, %cl
jne 0x3b4e
movl 0x8(%r15), %eax
addl %r14d, %eax
cmpl %eax, %ebx
jge 0x3b4e
pushq $0x2
popq %rsi
movl %ebx, %eax
cltd
idivl %esi
movl %edx, %ecx
movl %r14d, %eax
cltd
idivl %esi
cmpl %edx, %ecx
jmp 0x3b39
cmpl %r14d, %ebx
setne %cl
cmpl %eax, %r12d
setl %dl
orb %cl, %dl
jne 0x3b4e
addl 0x8(%r15), %eax
cmpl %eax, %r12d
jmp 0x3b5b
cmpl %r14d, %ebx
jl 0x3b4e
movl 0x8(%r15), %ecx
leal (%rcx,%r14), %edx
cmpl %edx, %ebx
setl %dl
cmpl %eax, %r12d
setge %sil
addl %eax, %ecx
cmpl %ecx, %r12d
setl %cl
andb %dl, %cl
andb %sil, %cl
cmpb $0x1, %cl
jne 0x3b4e
subl %ebx, %r12d
subl %r14d, %eax
cmpl %eax, %r12d
sete %al
jmp 0x3b5e
cmpl %eax, %r12d
setne %al
cmpl %r14d, %ebx
setl %cl
orb %al, %cl
je 0x3b52
xorl %eax, %eax
jmp 0x3b5e
movl 0x8(%r15), %eax
addl %r14d, %eax
cmpl %eax, %ebx
setl %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop