LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/util.c
// Function: strintmap_contains
bool strintmap_contains(StrIntMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;

    if (map->entries[index] == NULL) {
        return false;
    }
    else {
        StrIntMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return true;
            }
            current = current->next;
        }
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xea90
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl 0xc(%rcx)
movl %edx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xee02
movb $0x0, -0x1(%rbp)
jmp 0xee49
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xee45
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0xee37
movb $0x1, -0x1(%rbp)
jmp 0xee49
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xee15
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/util.c
// Function: strintmap_get
int strintmap_get(StrIntMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        fprintf(stderr, "no key=\"%s\"\n", key);
        exit(-1);
    }
    else {
        StrIntMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return current->val;
            }

            current = current->next;
        }

        fprintf(stderr, "no key=\"%s\"\n", key);
        exit(-1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xea90
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0xc(%rcx)
movl %edx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xeec2
movq 0x6155(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x222b(%rip), %rsi      # 0x110dc
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1160
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xef0c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0xeefe
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xeed5
movq 0x60e5(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x21bb(%rip), %rsi      # 0x110dc
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1160
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: glob(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&)
vector<string>
glob(const vector<string>& patterns)
{
    vector<string> paths_found;

	if(patterns.size() == 0)
	    return paths_found;

    glob_t glob_results;

    int glob_retval = glob(patterns[0].c_str(), 0, NULL, &glob_results);

    vector<string>::const_iterator iter = patterns.begin();

    while(++iter != patterns.end())
    {
        glob_retval = glob(iter->c_str(), GLOB_APPEND, NULL, &glob_results);
    }

    for(int path_index = 0; path_index < glob_results.gl_pathc; path_index++)
    {
        paths_found.push_back(glob_results.gl_pathv[path_index]);
    }

    globfree(&glob_results);

    return paths_found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xf270
movq -0x10(%rbp), %rdi
callq 0xf7a0
cmpq $0x0, %rax
jne 0xdfec
movb $0x1, -0x11(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0xe173
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf7c0
movq %rax, %rdi
callq 0xd170
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rcx
callq 0xd420
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf7e0
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xf850
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf870
movq -0xd0(%rbp), %rdi
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0xf810
testb $0x1, %al
jne 0xe056
jmp 0xe081
leaq -0x70(%rbp), %rdi
callq 0xf8a0
movq %rax, %rdi
callq 0xd170
movq %rax, %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rcx
callq 0xd420
movl %eax, -0x64(%rbp)
jmp 0xe023
movl $0x0, -0x7c(%rbp)
movslq -0x7c(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0xe15f
movq -0x58(%rbp), %rax
movslq -0x7c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xe0(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xd760
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0xf2c0
jmp 0xe0d8
movq -0xc8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xf290
jmp 0xe0ed
leaq -0xa0(%rbp), %rdi
callq 0xd240
leaq -0xa1(%rbp), %rdi
callq 0xd430
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0xe088
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0xe145
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xd240
leaq -0xa1(%rbp), %rdi
callq 0xd430
movq -0xc8(%rbp), %rdi
callq 0xf580
jmp 0xe195
leaq -0x60(%rbp), %rdi
callq 0xd0b0
movb $0x1, -0x11(%rbp)
movl $0x1, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xe185
movq -0xc8(%rbp), %rdi
callq 0xf580
movq -0xc0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: basename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
basename(const string& path)
{
    size_t pos = path.rfind("/");

    if(pos == std::string::npos)
        return path;

    return string(path, pos+1, string::npos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1e957(%rip), %rsi     # 0x2d06d
movq $-0x1, %rdx
callq 0xd710
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0xe73c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd190
jmp 0xe758
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movq $-0x1, %rcx
callq 0xd5a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: dirname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
dirname(const string& path)
{
    size_t pos = path.rfind("/");

    if(pos == std::string::npos)
        return path;
    else if(pos == 0)
        return "/";

    return string(path, 0, pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1e6f7(%rip), %rsi     # 0x2d06d
movq $-0x1, %rdx
callq 0xd710
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0xe99c
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd190
jmp 0xe9ff
cmpq $0x0, -0x18(%rbp)
jne 0xe9e8
leaq -0x19(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xd760
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x1e6ae(%rip), %rsi     # 0x2d06d
callq 0xf2c0
jmp 0xe9c6
leaq -0x19(%rbp), %rdi
callq 0xd430
jmp 0xe9ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0xd430
jmp 0xea09
jmp 0xe9ea
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xd5a0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: realpath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
realpath(const string& path)
{
    char* real_path = realpath(path.c_str(), NULL);

    string result;

    if(real_path != NULL)
    {
        result = real_path;

        free(real_path);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd170
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd110
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xd5b0
cmpq $0x0, -0x18(%rbp)
je 0xea99
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd590
jmp 0xea77
movq -0x18(%rbp), %rdi
callq 0xd4e0
jmp 0xea99
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xd240
jmp 0xeab6
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xeaac
movq -0x38(%rbp), %rdi
callq 0xd240
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xd750
nop
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: usb_sysfs_hw_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
usb_sysfs_hw_string(const string& sysfs_path)
{
    string serial_number = read_line( sysfs_path + "/serial" );

    if( serial_number.length() > 0 )
    {
        serial_number = format( "SNR=%s", serial_number.c_str() );
    }

    string vid = read_line( sysfs_path + "/idVendor" );

    string pid = read_line( sysfs_path + "/idProduct" );

    return format("USB VID:PID=%s:%s %s", vid.c_str(), pid.c_str(), serial_number.c_str() );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x1e15f(%rip), %rdx     # 0x2d08e
leaq -0x50(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xf8f0
movq -0x108(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xf140
jmp 0xef51
leaq -0x50(%rbp), %rdi
callq 0xd240
leaq -0x30(%rbp), %rdi
callq 0xd650
cmpq $0x0, %rax
jbe 0xefcc
leaq -0x30(%rbp), %rdi
callq 0xd170
movq %rax, %rdx
leaq 0x1e123(%rip), %rsi     # 0x2d09f
xorl %eax, %eax
leaq -0x80(%rbp), %rdi
callq 0xe770
jmp 0xef89
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xd4f0
leaq -0x80(%rbp), %rdi
callq 0xd240
jmp 0xefcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xd240
jmp 0xf137
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xf12e
movq -0x10(%rbp), %rsi
leaq 0x1e0cf(%rip), %rdx     # 0x2d0a6
leaq -0xc0(%rbp), %rdi
callq 0xf8f0
jmp 0xefe5
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xf140
jmp 0xeffa
leaq -0xc0(%rbp), %rdi
callq 0xd240
movq -0x10(%rbp), %rsi
leaq 0x1e09f(%rip), %rdx     # 0x2d0b0
leaq -0x100(%rbp), %rdi
callq 0xf8f0
jmp 0xf01f
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0xf140
jmp 0xf034
leaq -0x100(%rbp), %rdi
callq 0xd240
leaq -0xa0(%rbp), %rdi
callq 0xd170
movq %rax, -0x128(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0xd170
movq %rax, -0x120(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd170
movq -0x118(%rbp), %rdi
movq -0x128(%rbp), %rdx
movq -0x120(%rbp), %rcx
movq %rax, %r8
leaq 0x1e02d(%rip), %rsi     # 0x2d0bb
xorl %eax, %eax
callq 0xe770
jmp 0xf097
leaq -0xe0(%rbp), %rdi
callq 0xd240
leaq -0xa0(%rbp), %rdi
callq 0xd240
leaq -0x30(%rbp), %rdi
callq 0xd240
movq -0x110(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xd240
jmp 0xf12e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xf122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0xd240
jmp 0xf122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0xd240
leaq -0xa0(%rbp), %rdi
callq 0xd240
leaq -0x30(%rbp), %rdi
callq 0xd240
movq -0x58(%rbp), %rdi
callq 0xd750
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: read_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
read_line(const string& file)
{
    ifstream ifs(file.c_str(), ifstream::in);

    string line;

    if(ifs)
    {
        getline(ifs, line);
    }

    return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x238(%rbp)
movq %rdi, %rax
movq %rax, -0x240(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd170
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0xd7a0
movq -0x238(%rbp), %rdi
movb $0x0, -0x219(%rbp)
callq 0xd5b0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0xd510
movb %al, -0x22d(%rbp)
jmp 0xf1b4
movb -0x22d(%rbp), %al
testb $0x1, %al
jne 0xf1c0
jmp 0xf203
movq -0x238(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0xd0a0
jmp 0xf1d5
jmp 0xf203
movq -0x238(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
callq 0xd240
leaq -0x218(%rbp), %rdi
callq 0xd0d0
jmp 0xf23b
movb $0x1, -0x219(%rbp)
testb $0x1, -0x219(%rbp)
jne 0xf21f
movq -0x238(%rbp), %rdi
callq 0xd240
leaq -0x218(%rbp), %rdi
callq 0xd0d0
movq -0x240(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0xd750
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::read(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long)
size_t
Serial::read (std::vector<uint8_t> &buffer, size_t size)
{
  ScopedReadLock lock(this->pimpl_);
  uint8_t *buffer_ = new uint8_t[size];
  size_t bytes_read = this->pimpl_->read (buffer_, size);
  buffer.insert (buffer.end (), buffer_, buffer_+bytes_read);
  delete[] buffer_;
  return bytes_read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x8(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x12990
movq -0x18(%rbp), %rdi
callq 0xd040
movq %rax, -0x60(%rbp)
jmp 0x1188b
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x159f0
movq %rax, -0x70(%rbp)
jmp 0x118ae
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x12a90
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x12ac0
movq -0x80(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rax
movq %rdx, %rcx
addq %rax, %rcx
movq -0x48(%rbp), %rsi
callq 0x129f0
movq %rax, -0x78(%rbp)
jmp 0x118f5
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x1191a
movq -0x88(%rbp), %rdi
callq 0xd540
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x129c0
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x129c0
movq -0x30(%rbp), %rdi
callq 0xd750
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
size_t
Serial::read (std::string &buffer, size_t size)
{
  ScopedReadLock lock(this->pimpl_);
  uint8_t *buffer_ = new uint8_t[size];
  size_t bytes_read = this->pimpl_->read (buffer_, size);
  buffer.append (reinterpret_cast<const char*>(buffer_), bytes_read);
  delete[] buffer_;
  return bytes_read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x12990
movq -0x18(%rbp), %rdi
callq 0xd040
movq %rax, -0x48(%rbp)
jmp 0x11998
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x159f0
movq %rax, -0x58(%rbp)
jmp 0x119bb
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xd080
jmp 0x119d6
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x119ed
movq -0x60(%rbp), %rdi
callq 0xd540
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x129c0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x129c0
movq -0x30(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::readline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t
Serial::readline (string &buffer, size_t size, string eol)
{
  ScopedReadLock lock(this->pimpl_);
  size_t eol_len = eol.length ();
  uint8_t *buffer_ = static_cast<uint8_t*>
                              (alloca (size * sizeof (uint8_t)));
  size_t read_so_far = 0;
  while (true)
  {
    size_t bytes_read = this->read_ (buffer_ + read_so_far, 1);
    read_so_far += bytes_read;
    if (bytes_read == 0) {
      break; // Timeout occured on reading 1 byte
    }
    if (string (reinterpret_cast<const char*>
         (buffer_ + read_so_far - eol_len), eol_len) == eol) {
      break; // EOL found
    }
    if (read_so_far == size) {
      break; // Reached the maximum read length
    }
  }
  buffer.append(reinterpret_cast<const char*> (buffer_), read_so_far);
  return read_so_far;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rcx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x8(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x12990
movq -0x88(%rbp), %rdi
callq 0xd650
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0x11b2d
movq -0x90(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rax
addq %rax, %rsi
movl $0x1, %edx
callq 0x117a0
movq %rax, -0x98(%rbp)
jmp 0x11b52
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x11b86
jmp 0x11c34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x11c67
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd760
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
leaq -0x78(%rbp), %rdi
callq 0xd4a0
jmp 0x11bd6
movq -0x88(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x12b00
movb %al, -0xb1(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd240
leaq -0x79(%rbp), %rdi
callq 0xd430
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x11c0a
jmp 0x11c23
jmp 0x11c34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x79(%rbp), %rdi
callq 0xd430
jmp 0x11c67
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x11c2f
jmp 0x11c34
jmp 0x11b2b
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xd080
jmp 0x11c47
movq -0x40(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x129c0
movq -0xc0(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x129c0
movq -0x50(%rbp), %rdi
callq 0xd750
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::setPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
Serial::setPort (const string &port)
{
  ScopedReadLock rlock(this->pimpl_);
  ScopedWriteLock wlock(this->pimpl_);
  bool was_open = pimpl_->isOpen ();
  if (was_open) close();
  pimpl_->setPort (port);
  if (was_open) open ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x12990
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x12b90
jmp 0x123c8
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x154f0
movb %al, -0x39(%rbp)
jmp 0x123da
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x1241a
movq -0x38(%rbp), %rdi
callq 0x116c0
jmp 0x123f3
jmp 0x1241a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x12458
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x12bc0
jmp 0x12458
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x16230
jmp 0x1242d
testb $0x1, -0x2d(%rbp)
je 0x12440
movq -0x38(%rbp), %rdi
callq 0x116a0
jmp 0x1243e
jmp 0x12440
leaq -0x20(%rbp), %rdi
callq 0x12bc0
leaq -0x18(%rbp), %rdi
callq 0x129c0
addq $0x40, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x129c0
movq -0x28(%rbp), %rdi
callq 0xd750
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::MillisecondTimer::MillisecondTimer(unsigned int)
MillisecondTimer::MillisecondTimer (const uint32_t millis)
  : expiry(timespec_now())
{
  int64_t tv_nsec = expiry.tv_nsec + (millis * 1e6);
  if (tv_nsec >= 1e9) {
    int64_t sec_diff = tv_nsec / static_cast<int> (1e9);
    expiry.tv_nsec = tv_nsec - static_cast<int> (1e9 * sec_diff);
    expiry.tv_sec += sec_diff;
  } else {
    expiry.tv_nsec = tv_nsec;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x14150
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
cvtsi2sdq 0x8(%rax), %xmm1
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x19078(%rip), %xmm2    # 0x2d148
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x18(%rbp)
cvtsi2sdq -0x18(%rbp), %xmm0
movsd 0x19051(%rip), %xmm1    # 0x2d140
ucomisd %xmm1, %xmm0
jb 0x1413e
movq -0x18(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
cvtsi2sdq -0x20(%rbp), %xmm1
movsd 0x19020(%rip), %xmm0    # 0x2d140
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq %edx, %rdx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1414a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::MillisecondTimer::remaining()
int64_t
MillisecondTimer::remaining ()
{
  timespec now(timespec_now());
  int64_t millis = (expiry.tv_sec - now.tv_sec) * 1e3;
  millis += (expiry.tv_nsec - now.tv_nsec) / 1e6;
  return millis;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x14150
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq (%rax), %rcx
subq -0x18(%rbp), %rcx
cvtsi2sd %rcx, %xmm0
movsd 0x18f94(%rip), %xmm1    # 0x2d150
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
subq -0x10(%rbp), %rax
cvtsi2sd %rax, %xmm1
movsd 0x18f6a(%rip), %xmm0    # 0x2d148
divsd %xmm0, %xmm1
cvtsi2sdq -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::SerialImpl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, serial::bytesize_t, serial::parity_t, serial::stopbits_t, serial::flowcontrol_t)
Serial::SerialImpl::SerialImpl (const string &port, unsigned long baudrate,
                                bytesize_t bytesize,
                                parity_t parity, stopbits_t stopbits,
                                flowcontrol_t flowcontrol)
  : port_ (port), fd_ (-1), is_open_ (false), xonxoff_ (false), rtscts_ (false),
    baudrate_ (baudrate), parity_ (parity),
    bytesize_ (bytesize), stopbits_ (stopbits), flowcontrol_ (flowcontrol)
{
  pthread_mutex_init(&this->read_mutex, NULL);
  pthread_mutex_init(&this->write_mutex, NULL);
  if (port_.empty () == false)
    open ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0x219ef(%rip), %rax     # 0x35c80
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd190
movq -0x40(%rbp), %rdi
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
movb $0x0, 0x2c(%rdi)
movb $0x0, 0x2d(%rdi)
movb $0x0, 0x2e(%rdi)
addq $0x30, %rdi
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
callq 0x17fb0
jmp 0x142d6
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x48(%rdi)
movl -0x20(%rbp), %eax
movl %eax, 0x54(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x58(%rdi)
movl -0x24(%rbp), %eax
movl %eax, 0x5c(%rdi)
movl 0x10(%rbp), %eax
movl %eax, 0x60(%rdi)
addq $0x68, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd630
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd630
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0xd6f0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x14356
movq -0x40(%rbp), %rdi
callq 0x14370
jmp 0x1433d
jmp 0x14356
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xd240
jmp 0x1435c
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::close()
void
Serial::SerialImpl::close ()
{
  if (is_open_ == true) {
    if (fd_ != -1) {
      int ret;
      ret = ::close (fd_);
      if (ret == 0) {
        fd_ = -1;
      } else {
        THROW (IOException, errno);
      }
    }
    is_open_ = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movb 0x2c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x147ce
movq -0x50(%rbp), %rax
cmpl $-0x1, 0x28(%rax)
je 0x147c6
movq -0x50(%rbp), %rax
movl 0x28(%rax), %edi
callq 0xd800
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x14718
movq -0x50(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
jmp 0x147c4
movb $0x1, -0x45(%rbp)
movl $0x58, %edi
callq 0xd1e0
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xd760
movq -0x58(%rbp), %rdx
leaq 0x18a6f(%rip), %rsi     # 0x2d1b1
leaq -0x30(%rbp), %rdi
callq 0xf2c0
jmp 0x1474d
callq 0xd060
movq -0x60(%rbp), %rdi
movl (%rax), %ecx
leaq -0x30(%rbp), %rsi
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x183c0
jmp 0x14768
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x21541(%rip), %rsi     # 0x35cb8
leaq 0x3bf2(%rip), %rdx      # 0x18370
callq 0xd720
jmp 0x147dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x147a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd240
leaq -0x31(%rbp), %rdi
callq 0xd430
testb $0x1, -0x45(%rbp)
jne 0x147b9
jmp 0x147c2
movq -0x60(%rbp), %rdi
callq 0xd2c0
jmp 0x147d4
jmp 0x147c6
movq -0x50(%rbp), %rax
movb $0x0, 0x2c(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xd750
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::available()
size_t
Serial::SerialImpl::available ()
{
  if (!is_open_) {
    return 0;
  }
  int count = 0;
  if (-1 == ioctl (fd_, TIOCINQ, &count)) {
      THROW (IOException, errno);
  } else {
      return static_cast<size_t> (count);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, 0x2c(%rax)
jne 0x15537
movq $0x0, -0x8(%rbp)
jmp 0x15618
movq -0x58(%rbp), %rax
movl $0x0, -0x14(%rbp)
movl 0x28(%rax), %edi
movl $0x541b, %esi           # imm = 0x541B
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0xd5e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x15610
movb $0x1, -0x4d(%rbp)
movl $0x58, %edi
callq 0xd1e0
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xd760
movq -0x60(%rbp), %rdx
leaq 0x17c23(%rip), %rsi     # 0x2d1b1
leaq -0x38(%rbp), %rdi
callq 0xf2c0
jmp 0x15599
callq 0xd060
movq -0x68(%rbp), %rdi
movl (%rax), %ecx
leaq -0x38(%rbp), %rsi
movl $0x1e6, %edx            # imm = 0x1E6
callq 0x183c0
jmp 0x155b4
movq -0x68(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x206f5(%rip), %rsi     # 0x35cb8
leaq 0x2da6(%rip), %rdx      # 0x18370
callq 0xd720
jmp 0x1562b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x155f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd240
leaq -0x39(%rbp), %rdi
callq 0xd430
testb $0x1, -0x4d(%rbp)
jne 0x15605
jmp 0x1560e
movq -0x68(%rbp), %rdi
callq 0xd2c0
jmp 0x15622
movslq -0x14(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xd750
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::waitForChange()
bool
Serial::SerialImpl::waitForChange ()
{
#ifndef TIOCMIWAIT

while (is_open_ == true) {

    int status;

    if (-1 == ioctl (fd_, TIOCMGET, &status))
    {
        stringstream ss;
        ss << "waitForChange failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
        throw(SerialException(ss.str().c_str()));
    }
    else
    {
        if (0 != (status & TIOCM_CTS)
         || 0 != (status & TIOCM_DSR)
         || 0 != (status & TIOCM_RI)
         || 0 != (status & TIOCM_CD))
        {
          return true;
        }
    }

    usleep(1000);
  }

  return false;
#else
  int command = (TIOCM_CD|TIOCM_DSR|TIOCM_RI|TIOCM_CTS);

  if (-1 == ioctl (fd_, TIOCMIWAIT, &command)) {
    stringstream ss;
    ss << "waitForDSR failed on a call to ioctl(TIOCMIWAIT): "
       << errno << " " << strerror(errno);
    throw(SerialException(ss.str().c_str()));
  }
  return true;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1e0, -0xc(%rbp)      # imm = 0x1E0
movl 0x28(%rax), %edi
movl $0x545c, %esi           # imm = 0x545C
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0xd5e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x17396
leaq -0x198(%rbp), %rdi
callq 0xd2a0
leaq -0x188(%rbp), %rdi
leaq 0x1639f(%rip), %rsi     # 0x2d5f5
callq 0xd3a0
movq %rax, -0x1d8(%rbp)
jmp 0x17264
callq 0xd060
movq -0x1d8(%rbp), %rdi
movl (%rax), %esi
callq 0xd740
movq %rax, -0x1e0(%rbp)
jmp 0x17280
movq -0x1e0(%rbp), %rdi
leaq 0x16365(%rip), %rsi     # 0x2d5f3
callq 0xd3a0
movq %rax, -0x1e8(%rbp)
jmp 0x1729c
callq 0xd060
movl (%rax), %edi
callq 0xd100
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
callq 0xd3a0
jmp 0x172b9
movb $0x1, -0x1c9(%rbp)
movl $0x28, %edi
callq 0xd1e0
movq %rax, -0x1f0(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xd390
jmp 0x172e6
leaq -0x1c8(%rbp), %rdi
callq 0xd170
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
callq 0x17ff0
jmp 0x17303
movq -0x1f0(%rbp), %rdi
movb $0x0, -0x1c9(%rbp)
leaq 0x1e988(%rip), %rsi     # 0x35ca0
leaq 0xe11(%rip), %rdx       # 0x18130
callq 0xd720
jmp 0x173af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x17388
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x1736f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xd240
testb $0x1, -0x1c9(%rbp)
jne 0x1737a
jmp 0x17386
movq -0x1f0(%rbp), %rdi
callq 0xd2c0
jmp 0x17388
leaq -0x198(%rbp), %rdi
callq 0xd2e0
jmp 0x173a3
movb $0x1, %al
andb $0x1, %al
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0xd750
nop
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::getCTS()
bool
Serial::SerialImpl::getCTS ()
{
  if (is_open_ == false) {
    throw PortNotOpenedException ("Serial::getCTS");
  }

  int status;

  if (-1 == ioctl (fd_, TIOCMGET, &status))
  {
    stringstream ss;
    ss << "getCTS failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
    throw(SerialException(ss.str().c_str()));
  }
  else
  {
    return 0 != (status & TIOCM_CTS);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movb 0x2c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17433
movl $0x28, %edi
callq 0xd1e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
leaq 0x16233(%rip), %rsi     # 0x2d628
callq 0x18610
jmp 0x173fc
movq -0x1d8(%rbp), %rdi
leaq 0x1e8c6(%rip), %rsi     # 0x35cd0
leaq 0x133f(%rip), %rdx      # 0x18750
callq 0xd720
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd2c0
jmp 0x175b9
movq -0x1d0(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0xd5e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x175a1
leaq -0x1a0(%rbp), %rdi
callq 0xd2a0
leaq -0x190(%rbp), %rdi
leaq 0x161c1(%rip), %rsi     # 0x2d637
callq 0xd3a0
movq %rax, -0x1e0(%rbp)
jmp 0x17484
callq 0xd060
movq -0x1e0(%rbp), %rdi
movl (%rax), %esi
callq 0xd740
movq %rax, -0x1e8(%rbp)
jmp 0x174a0
movq -0x1e8(%rbp), %rdi
leaq 0x16145(%rip), %rsi     # 0x2d5f3
callq 0xd3a0
movq %rax, -0x1f0(%rbp)
jmp 0x174bc
callq 0xd060
movl (%rax), %edi
callq 0xd100
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
callq 0xd3a0
jmp 0x174d9
movb $0x1, -0x1c1(%rbp)
movl $0x28, %edi
callq 0xd1e0
movq %rax, -0x1f8(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xd390
jmp 0x17506
leaq -0x1c0(%rbp), %rdi
callq 0xd170
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x17ff0
jmp 0x17523
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
leaq 0x1e768(%rip), %rsi     # 0x35ca0
leaq 0xbf1(%rip), %rdx       # 0x18130
callq 0xd720
jmp 0x175c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x17593
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1757a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xd240
testb $0x1, -0x1c1(%rbp)
jne 0x17585
jmp 0x17591
movq -0x1f8(%rbp), %rdi
callq 0xd2c0
jmp 0x17593
leaq -0x1a0(%rbp), %rdi
callq 0xd2e0
jmp 0x175b9
movl -0x18(%rbp), %ecx
andl $0x20, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::getDSR()
bool
Serial::SerialImpl::getDSR ()
{
  if (is_open_ == false) {
    throw PortNotOpenedException ("Serial::getDSR");
  }

  int status;

  if (-1 == ioctl (fd_, TIOCMGET, &status))
  {
      stringstream ss;
      ss << "getDSR failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
      throw(SerialException(ss.str().c_str()));
  }
  else
  {
      return 0 != (status & TIOCM_DSR);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movb 0x2c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17653
movl $0x28, %edi
callq 0xd1e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
leaq 0x1604f(%rip), %rsi     # 0x2d664
callq 0x18610
jmp 0x1761c
movq -0x1d8(%rbp), %rdi
leaq 0x1e6a6(%rip), %rsi     # 0x35cd0
leaq 0x111f(%rip), %rdx      # 0x18750
callq 0xd720
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd2c0
jmp 0x177dc
movq -0x1d0(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0xd5e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x177c1
leaq -0x1a0(%rbp), %rdi
callq 0xd2a0
leaq -0x190(%rbp), %rdi
leaq 0x15fdd(%rip), %rsi     # 0x2d673
callq 0xd3a0
movq %rax, -0x1e0(%rbp)
jmp 0x176a4
callq 0xd060
movq -0x1e0(%rbp), %rdi
movl (%rax), %esi
callq 0xd740
movq %rax, -0x1e8(%rbp)
jmp 0x176c0
movq -0x1e8(%rbp), %rdi
leaq 0x15f25(%rip), %rsi     # 0x2d5f3
callq 0xd3a0
movq %rax, -0x1f0(%rbp)
jmp 0x176dc
callq 0xd060
movl (%rax), %edi
callq 0xd100
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
callq 0xd3a0
jmp 0x176f9
movb $0x1, -0x1c1(%rbp)
movl $0x28, %edi
callq 0xd1e0
movq %rax, -0x1f8(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xd390
jmp 0x17726
leaq -0x1c0(%rbp), %rdi
callq 0xd170
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x17ff0
jmp 0x17743
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
leaq 0x1e548(%rip), %rsi     # 0x35ca0
leaq 0x9d1(%rip), %rdx       # 0x18130
callq 0xd720
jmp 0x177e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x177b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1779a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xd240
testb $0x1, -0x1c1(%rbp)
jne 0x177a5
jmp 0x177b1
movq -0x1f8(%rbp), %rdi
callq 0xd2c0
jmp 0x177b3
leaq -0x1a0(%rbp), %rdi
callq 0xd2e0
jmp 0x177dc
movl -0x18(%rbp), %ecx
andl $0x100, %ecx            # imm = 0x100
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::getRI()
bool
Serial::SerialImpl::getRI ()
{
  if (is_open_ == false) {
    throw PortNotOpenedException ("Serial::getRI");
  }

  int status;

  if (-1 == ioctl (fd_, TIOCMGET, &status))
  {
    stringstream ss;
    ss << "getRI failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
    throw(SerialException(ss.str().c_str()));
  }
  else
  {
    return 0 != (status & TIOCM_RI);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movb 0x2c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17873
movl $0x28, %edi
callq 0xd1e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
leaq 0x15e6b(%rip), %rsi     # 0x2d6a0
callq 0x18610
jmp 0x1783c
movq -0x1d8(%rbp), %rdi
leaq 0x1e486(%rip), %rsi     # 0x35cd0
leaq 0xeff(%rip), %rdx       # 0x18750
callq 0xd720
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd2c0
jmp 0x179fc
movq -0x1d0(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0xd5e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x179e1
leaq -0x1a0(%rbp), %rdi
callq 0xd2a0
leaq -0x190(%rbp), %rdi
leaq 0x15df8(%rip), %rsi     # 0x2d6ae
callq 0xd3a0
movq %rax, -0x1e0(%rbp)
jmp 0x178c4
callq 0xd060
movq -0x1e0(%rbp), %rdi
movl (%rax), %esi
callq 0xd740
movq %rax, -0x1e8(%rbp)
jmp 0x178e0
movq -0x1e8(%rbp), %rdi
leaq 0x15d05(%rip), %rsi     # 0x2d5f3
callq 0xd3a0
movq %rax, -0x1f0(%rbp)
jmp 0x178fc
callq 0xd060
movl (%rax), %edi
callq 0xd100
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
callq 0xd3a0
jmp 0x17919
movb $0x1, -0x1c1(%rbp)
movl $0x28, %edi
callq 0xd1e0
movq %rax, -0x1f8(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xd390
jmp 0x17946
leaq -0x1c0(%rbp), %rdi
callq 0xd170
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x17ff0
jmp 0x17963
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
leaq 0x1e328(%rip), %rsi     # 0x35ca0
leaq 0x7b1(%rip), %rdx       # 0x18130
callq 0xd720
jmp 0x17a05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x179d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x179ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xd240
testb $0x1, -0x1c1(%rbp)
jne 0x179c5
jmp 0x179d1
movq -0x1f8(%rbp), %rdi
callq 0xd2c0
jmp 0x179d3
leaq -0x1a0(%rbp), %rdi
callq 0xd2e0
jmp 0x179fc
movl -0x18(%rbp), %ecx
andl $0x80, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/unix.cc
// Function: serial::Serial::SerialImpl::getCD()
bool
Serial::SerialImpl::getCD ()
{
  if (is_open_ == false) {
    throw PortNotOpenedException ("Serial::getCD");
  }

  int status;

  if (-1 == ioctl (fd_, TIOCMGET, &status))
  {
    stringstream ss;
    ss << "getCD failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
    throw(SerialException(ss.str().c_str()));
  }
  else
  {
    return 0 != (status & TIOCM_CD);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movb 0x2c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17a93
movl $0x28, %edi
callq 0xd1e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
leaq 0x15c85(%rip), %rsi     # 0x2d6da
callq 0x18610
jmp 0x17a5c
movq -0x1d8(%rbp), %rdi
leaq 0x1e266(%rip), %rsi     # 0x35cd0
leaq 0xcdf(%rip), %rdx       # 0x18750
callq 0xd720
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd2c0
jmp 0x17c19
movq -0x1d0(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0xd5e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x17c01
leaq -0x1a0(%rbp), %rdi
callq 0xd2a0
leaq -0x190(%rbp), %rdi
leaq 0x15c12(%rip), %rsi     # 0x2d6e8
callq 0xd3a0
movq %rax, -0x1e0(%rbp)
jmp 0x17ae4
callq 0xd060
movq -0x1e0(%rbp), %rdi
movl (%rax), %esi
callq 0xd740
movq %rax, -0x1e8(%rbp)
jmp 0x17b00
movq -0x1e8(%rbp), %rdi
leaq 0x15ae5(%rip), %rsi     # 0x2d5f3
callq 0xd3a0
movq %rax, -0x1f0(%rbp)
jmp 0x17b1c
callq 0xd060
movl (%rax), %edi
callq 0xd100
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
callq 0xd3a0
jmp 0x17b39
movb $0x1, -0x1c1(%rbp)
movl $0x28, %edi
callq 0xd1e0
movq %rax, -0x1f8(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xd390
jmp 0x17b66
leaq -0x1c0(%rbp), %rdi
callq 0xd170
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x17ff0
jmp 0x17b83
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
leaq 0x1e108(%rip), %rsi     # 0x35ca0
leaq 0x591(%rip), %rdx       # 0x18130
callq 0xd720
jmp 0x17c22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x17bf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x17bda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xd240
testb $0x1, -0x1c1(%rbp)
jne 0x17be5
jmp 0x17bf1
movq -0x1f8(%rbp), %rdi
callq 0xd2c0
jmp 0x17bf3
leaq -0x1a0(%rbp), %rdi
callq 0xd2e0
jmp 0x17c19
movl -0x18(%rbp), %ecx
andl $0x40, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xd750
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/serial/serial.h
// Function: serial::IOException::IOException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, char const*)
explicit IOException (std::string file, int line, const char * description)
    : file_(file), line_(line), errno_(0) {
      std::stringstream ss;
      ss << "IO Exception: " << description;
      ss << ", file " << file_ << ", line " << line_ << ".";
      e_what_ = ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rsi, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x187e0
movq -0x1f0(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
leaq 0x1db6a(%rip), %rax     # 0x35d20
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x1e0(%rbp)
callq 0xd190
jmp 0x181cb
movq -0x1f0(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x28(%rdi)
addq $0x30, %rdi
movq %rdi, -0x1f8(%rbp)
callq 0xd5b0
movq -0x1f0(%rbp), %rax
movl $0x0, 0x50(%rax)
leaq -0x1b8(%rbp), %rdi
callq 0xd2a0
jmp 0x18204
leaq -0x1a8(%rbp), %rdi
leaq 0x1551c(%rip), %rsi     # 0x2d72e
callq 0xd3a0
movq %rax, -0x200(%rbp)
jmp 0x18220
movq -0x200(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd3a0
jmp 0x18232
leaq -0x1a8(%rbp), %rdi
leaq 0x154fd(%rip), %rsi     # 0x2d73d
callq 0xd3a0
movq %rax, -0x208(%rbp)
jmp 0x1824e
movq -0x208(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
addq $0x8, %rsi
callq 0xd360
movq %rax, -0x210(%rbp)
jmp 0x1826e
movq -0x210(%rbp), %rdi
leaq 0x154c9(%rip), %rsi     # 0x2d745
callq 0xd3a0
movq %rax, -0x218(%rbp)
jmp 0x1828a
movq -0x218(%rbp), %rdi
movq -0x1f0(%rbp), %rax
movl 0x28(%rax), %esi
callq 0xd740
movq %rax, -0x220(%rbp)
jmp 0x182a9
movq -0x220(%rbp), %rdi
leaq 0x15475(%rip), %rsi     # 0x2d72c
callq 0xd3a0
jmp 0x182be
leaq -0x1d8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xd390
jmp 0x182d3
movq -0x1f0(%rbp), %rdi
addq $0x30, %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xd4f0
leaq -0x1d8(%rbp), %rdi
callq 0xd240
leaq -0x1b8(%rbp), %rdi
callq 0xd2e0
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x18357
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1833f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xd2e0
movq -0x1f8(%rbp), %rdi
callq 0xd240
movq -0x1e0(%rbp), %rdi
callq 0xd240
movq -0x1f0(%rbp), %rdi
callq 0xd7c0
movq -0x28(%rbp), %rdi
callq 0xd750
nopl (%rax)