LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: hzeller[P]gcode-cli/main.cc
// Function: ReadResponseLine(bool, MachineConnection*, std::basic_string_view<char, std::char_traits<char>>*)
static AckResponse ReadResponseLine(bool use_flow_control,
                                    MachineConnection *machine,
                                    std::string_view *return_message) {
    if (!use_flow_control) {
        return AckResponse::kOk;  // Don't read, always assume 'ok'.
    }

    const std::string_view ack_msg = machine->ResponseLines().ReadLine();
    if (machine->ResponseLines().is_eof()) {
        *return_message = "Nothing received from machine: Connection closed";
        return AckResponse::kError;
    }

    // TODO: there might be other ways machines report ok or errors.

    // OK response.
    if (hasPrefixIgnoreCase(ack_msg, "ok")) {
        return AckResponse::kOk;
    }

    // Any non-ok messages are useful to print. Return.
    *return_message = ack_msg;

    // ERROR response.
    if (hasPrefixIgnoreCase(ack_msg, "error") ||
        hasPrefixIgnoreCase(ack_msg, "alarm")) {
        return AckResponse::kError;
    }

    // Neither one or the other, so regard this as just a line that is not
    // a completed response yet.
    return AckResponse::kMessage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
testb $0x1, -0x5(%rbp)
jne 0x313d
movl $0x0, -0x4(%rbp)
jmp 0x3289
movq -0x10(%rbp), %rdi
callq 0x38e0
movq %rax, %rdi
callq 0x5dc0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38e0
movq %rax, %rdi
callq 0x3520
testb $0x1, %al
jne 0x316d
jmp 0x319c
leaq -0x38(%rbp), %rdi
leaq 0x4810(%rip), %rsi      # 0x7988
callq 0x3900
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3289
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0x4802(%rip), %rsi      # 0x79b9
callq 0x3900
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x3300
testb $0x1, %al
jne 0x31d7
jmp 0x31e3
movl $0x0, -0x4(%rbp)
jmp 0x3289
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x78(%rbp), %rdi
leaq 0x47ab(%rip), %rsi      # 0x79bc
callq 0x3900
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
callq 0x3300
testb $0x1, %al
jne 0x3279
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x98(%rbp), %rdi
leaq 0x4772(%rip), %rsi      # 0x79c2
callq 0x3900
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq 0x3300
testb $0x1, %al
jne 0x3279
jmp 0x3282
movl $0x1, -0x4(%rbp)
jmp 0x3289
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-cli/main.cc
// Function: handle_error_or_exit()
static void handle_error_or_exit() {
#define ALERT_ON  "\033[41m\033[30m"
#define ALERT_OFF "\033[0m"

    if (isatty(STDIN_FILENO)) {  // interactive.
        fprintf(stderr, ALERT_ON
                "[ Didn't get OK. Continue: ENTER; stop: CTRL-C ]" ALERT_OFF
                "\n");
        getchar();
    } else {
        fprintf(stderr,
                "[ Received error. Non-interactive session "
                "does not allow for user feedback. Bailing out.]"
                "\n");
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x23f0
cmpl $0x0, %eax
je 0x32cf
movq 0x7d21(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x4707(%rip), %rsi      # 0x79c8
movb $0x0, %al
callq 0x2360
callq 0x2330
jmp 0x32f1
movq 0x7d02(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x4728(%rip), %rsi      # 0x7a08
movb $0x0, %al
callq 0x2360
movl $0x1, %edi
callq 0x22c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-cli/machine-connection.cc
// Function: MachineConnection::Open(char const*)
MachineConnection *MachineConnection::Open(const char *descriptor) {
    if (descriptor == nullptr) return nullptr;
    if (strcmp(descriptor, "-") == 0) {
        return new MachineConnection(STDOUT_FILENO, STDIN_FILENO);
    }
    if (const int fd = OpenTTY(descriptor); fd >= 0) {
        return new MachineConnection(fd, fd);
    }
    if (const int fd = OpenTCPSocket(descriptor); fd >= 0) {
        return new MachineConnection(fd, fd);
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x42b0
movq $0x0, -0x8(%rbp)
jmp 0x43dc
movq -0x10(%rbp), %rdi
leaq 0x2e6e(%rip), %rsi      # 0x7129
callq 0x2340
cmpl $0x0, %eax
jne 0x4313
movl $0x48, %edi
callq 0x2230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl $0x1, %esi
xorl %edx, %edx
callq 0x4210
jmp 0x42e7
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x43dc
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x2240
jmp 0x43e6
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3900
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x43f0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x437c
movl $0x48, %edi
callq 0x2230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %edx
movl %edx, %esi
callq 0x4210
jmp 0x4356
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x43dc
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x2240
jmp 0x43e6
movq -0x10(%rbp), %rdi
callq 0x4070
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x43d4
movl $0x48, %edi
callq 0x2230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x34(%rbp), %edx
movl %edx, %esi
callq 0x4210
jmp 0x43ae
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x43dc
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x2240
jmp 0x43e6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2400
nop
// File: hzeller[P]gcode-cli/machine-connection.cc
// Function: OpenTTY(std::basic_string_view<char, std::char_traits<char>>)
static int OpenTTY(std::string_view descriptor) {
    auto first_comma = descriptor.find(',');
    const std::string path(descriptor.substr(0, first_comma));
    const std::string_view tty_params = (first_comma != std::string_view::npos)
                                            ? descriptor.substr(first_comma + 1)
                                            : "";
    const int fd = open(path.c_str(), O_RDWR | O_NOCTTY | O_SYNC);
    if (fd < 0) {
        return -1;
    }
    if (!SetTTYParams(fd, tty_params)) {
        return -1;
    }
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xa0(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x2c, %esi
callq 0x4d70
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x4e10
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2410
movq -0x98(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4ea0
jmp 0x446c
leaq -0x51(%rbp), %rdi
callq 0x2260
cmpq $-0x1, -0x20(%rbp)
je 0x44bb
movq -0x20(%rbp), %rsi
incq %rsi
leaq -0x18(%rbp), %rdi
movq $-0x1, %rdx
callq 0x4e10
movq %rdx, -0xb8(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x44a3
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x44cb
leaq -0x78(%rbp), %rdi
leaq 0x2d02(%rip), %rsi      # 0x71c8
callq 0x3900
leaq -0x40(%rbp), %rdi
callq 0x2120
movq %rax, %rdi
xorl %eax, %eax
movl $0x101102, %esi         # imm = 0x101102
callq 0x21b0
movl %eax, -0xbc(%rbp)
jmp 0x44eb
movl -0xbc(%rbp), %eax
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
jge 0x453b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x80(%rbp)
jmp 0x458d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x2260
jmp 0x45a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2180
jmp 0x45a2
movl -0x7c(%rbp), %edi
movups -0x78(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x4940
movb %al, -0xbd(%rbp)
jmp 0x4564
movb -0xbd(%rbp), %al
testb $0x1, %al
jne 0x4580
jmp 0x4570
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x80(%rbp)
jmp 0x458d
movl -0x7c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2180
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2400
nopl (%rax,%rax)
// File: hzeller[P]gcode-cli/machine-connection.cc
// Function: MachineConnection::DiscardPendingInput(int, _IO_FILE*)
int MachineConnection::DiscardPendingInput(int timeout_ms,
                                           FILE *echo_discarded) {
    if (input_fd_ < 0) return 0;
    int total_bytes = 0;
    char buf[128];
    while (AwaitReadReady(input_fd_, timeout_ms) > 0) {
        int r = read(input_fd_, buf, sizeof(buf));
        if (r < 0) {
            perror("reading trouble");
            return -1;
        }
        total_bytes += r;
        if (r > 0 && echo_discarded) {
            fwrite(buf, r, 1, echo_discarded);
        }
    }
    return total_bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpl $0x0, 0x4(%rax)
jge 0x45e3
movl $0x0, -0x4(%rbp)
jmp 0x4683
movl $0x0, -0x24(%rbp)
movq -0xc0(%rbp), %rax
movl 0x4(%rax), %edi
movl -0x14(%rbp), %esi
callq 0x4690
cmpl $0x0, %eax
jle 0x467d
movq -0xc0(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0xb0(%rbp), %rsi
movl $0x80, %edx
callq 0x2370
movl %eax, -0xb4(%rbp)
cmpl $0x0, -0xb4(%rbp)
jge 0x4640
leaq 0x3599(%rip), %rdi      # 0x7bcb
callq 0x2200
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4683
movl -0xb4(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0xb4(%rbp)
jle 0x4678
cmpq $0x0, -0x20(%rbp)
je 0x4678
leaq -0xb0(%rbp), %rdi
movslq -0xb4(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x2440
jmp 0x45ea
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: hzeller[P]gcode-cli/machine-connection.cc
// Function: AwaitReadReady(int, int)
static int AwaitReadReady(int fd, int timeout_millis) {
    fd_set read_fds;
    FD_ZERO(&read_fds);
    FD_SET(fd, &read_fds);

    struct timeval tv;
    tv.tv_sec = timeout_millis / 1000;
    tv.tv_usec = (timeout_millis % 1000) * 1000;

    FD_SET(fd, &read_fds);
    int s = select(fd + 1, &read_fds, NULL, NULL, &tv);
    if (s < 0) return -1;
    return tv.tv_usec / 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl $0x0, -0x94(%rbp)
movl -0x94(%rbp), %eax
cmpq $0x10, %rax
jae 0x46eb
movq -0xa0(%rbp), %rax
movl -0x94(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x46b9
jmp 0x46ed
movl -0x8(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movl -0xc(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
cltq
movq %rax, -0xa8(%rbp)
movl -0x8(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movl -0x8(%rbp), %edi
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xb0(%rbp), %r8
movq %rcx, %rdx
callq 0x2220
movl %eax, -0xb4(%rbp)
cmpl $0x0, -0xb4(%rbp)
jge 0x47c1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47d5
movq -0xa8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-cli/machine-connection.cc
// Function: MachineConnection::WriteBlocks(char*, std::vector<std::basic_string_view<char, std::char_traits<char>>, std::allocator<std::basic_string_view<char, std::char_traits<char>>>> const&)
bool MachineConnection::WriteBlocks(
    char *scratch_buffer, const std::vector<std::string_view> &blocks) {
    // Note: not using writev(), as snippets can be a lot and writev() has a
    // bunch of limitations (e.g. UIO_MAXIOV == 1024). Thus simply
    // reassmbling into buffer.
    char *pos = scratch_buffer;
    for (auto block : blocks) {
        memcpy(pos, block.data(), block.size());
        pos += block.size();
    }
    return reliable_write(output_fd_, scratch_buffer, pos - scratch_buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3540
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3570
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x35a0
testb $0x1, %al
jne 0x4849
jmp 0x48ab
leaq -0x30(%rbp), %rdi
callq 0x35e0
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3670
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3650
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x21e0
leaq -0x48(%rbp), %rdi
callq 0x3650
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x36f0
jmp 0x4836
movq -0x50(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x48d0
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: hzeller[P]gcode-cli/machine-connection.cc
// Function: reliable_write(int, char const*, int)
static bool reliable_write(int fd, const char *buffer, int len) {
    while (len) {
        int w = write(fd, buffer, len);
        if (w < 0) return false;
        len -= w;
        buffer += w;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4925
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x20d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x4907
movb $0x0, -0x1(%rbp)
jmp 0x4929
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x48e2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-cli/machine-connection.cc
// Function: SetTTYSpeed(int, termios2*, int)
static bool SetTTYSpeed(int fd, tty_termios_t *tty, int speed_number) {
    if (speed_number < 0) {
        fprintf(stderr, "Invalid speed %d\n", speed_number);
        return false;
    }
#ifdef USE_TERMIOS
    speed_t speed = B115200;
    const std::map<int, speed_t> selectable_speeds = AvailableTTYSpeeds();
    const auto found = selectable_speeds.find(speed_number);
    if (found == selectable_speeds.end()) {
        if (MaybeAppleSpecificFallback(fd, speed_number)) {
            return true;  // averted :)
        }
        fprintf(stderr, "Invalid speed '%d'; valid speeds are [", speed_number);
        const char *sep = "";
        for (const auto &[speed, _] : selectable_speeds) {
            fprintf(stderr, "%s%d", sep, speed);
            sep = ", ";
        }
        fprintf(stderr, "]\n");
        return false;
    }
    speed = found->second;
    if (cfsetospeed(tty, speed) < 0 || cfsetispeed(tty, speed) < 0) {
        fprintf(stderr, "While attempting to set speed to %d bps\n",
                speed_number);
        perror("Issue while setting tty-speed");
        return false;
    }
#else
    /* Clear the current output baud rate and fill a new value */
    tty->c_cflag &= ~CBAUD;
    tty->c_cflag |= BOTHER;
    tty->c_ospeed = speed_number;

    /* Clear the current input baud rate and fill a new value */
    tty->c_cflag &= ~(CBAUD << IBSHIFT);
    tty->c_cflag |= BOTHER << IBSHIFT;
    tty->c_ispeed = speed_number;
#endif

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x4d09
movq 0x62e9(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x2f89(%rip), %rsi      # 0x7c85
movb $0x0, %al
callq 0x2360
movb $0x0, -0x1(%rbp)
jmp 0x4d61
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xffffeff0, %ecx       # imm = 0xFFFFEFF0
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x1000, %ecx           # imm = 0x1000
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xeff0ffff, %ecx       # imm = 0xEFF0FFFF
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x10000000, %ecx       # imm = 0x10000000
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::Refill()
bool BufferedLineReader::Refill() {
    data_begin_ = buffer_;
    data_end_ = data_begin_;
    if (eof_) return false;
    if (!remainder_.empty()) {
        // get remainder to the beginning of the buffer.
        memmove(data_begin_, remainder_.data(), remainder_.size());
        data_end_ += remainder_.size();
    }
    const ssize_t r = read(fd_, data_end_, buffer_size_ - remainder_.size());
    if (r > 0) {
        data_end_ += r;
    } else {
        eof_ = true;
        if (r < 0) perror("Reading input");
        if (!remainder_.empty()) {
            // Close remainder with a newline
            *data_end_++ = '\n';
        }
    }
    remainder_ = {};
    return data_end_ > data_begin_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x28(%rax)
testb $0x1, 0x19(%rax)
je 0x5963
movb $0x0, -0x1(%rbp)
jmp 0x5a89
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x3690
testb $0x1, %al
jne 0x59c6
movq -0x30(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
callq 0x3670
movq -0x30(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x30, %rdi
callq 0x3650
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x23d0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x3650
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rdi
movl (%rdi), %eax
movl %eax, -0x4c(%rbp)
movq 0x28(%rdi), %rax
movq %rax, -0x48(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x58(%rbp)
addq $0x30, %rdi
callq 0x3650
movq -0x58(%rbp), %rdx
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
subq %rax, %rdx
callq 0x2370
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x5a18
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
jmp 0x5a5c
movq -0x30(%rbp), %rax
movb $0x1, 0x19(%rax)
cmpq $0x0, -0x18(%rbp)
jge 0x5a33
leaq 0x227a(%rip), %rdi      # 0x7ca8
callq 0x2200
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x3690
testb $0x1, %al
jne 0x5a5a
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x28(%rcx)
movb $0xa, (%rax)
jmp 0x5a5c
leaq -0x28(%rbp), %rdi
callq 0x3600
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, 0x30(%rcx)
movq -0x20(%rbp), %rax
movq %rax, 0x38(%rcx)
movq 0x28(%rcx), %rax
cmpq 0x20(%rcx), %rax
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::ReadNextLines(unsigned long)
std::vector<std::string_view> BufferedLineReader::ReadNextLines(size_t n) {
    std::vector<std::string_view> result;
    result.reserve(n);
    if (data_begin_ >= data_end_ && !Refill()) {
        return result;
    }
    char *end_line;
    while ((end_line = std::find_if(data_begin_, data_end_, [](char c) {
                return c == '\n' || c == '\r';
            })) != data_end_) {
        auto line = MakeCommentFreeLine(data_begin_, end_line);
        if (!line.empty()) result.push_back(line);
        data_begin_ = end_line + 1;
        if (result.size() >= n) {
            return result;
        }
    }
    remainder_ = std::string_view(data_begin_, data_end_ - data_begin_);
    data_begin_ = data_end_;  // consume all.
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x60f0
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6110
jmp 0x5ae2
movq -0x70(%rbp), %rcx
movq 0x20(%rcx), %rax
cmpq 0x28(%rcx), %rax
jb 0x5b31
movq -0x70(%rbp), %rdi
callq 0x5930
movb %al, -0x79(%rbp)
jmp 0x5afe
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x5b31
jmp 0x5b07
movb $0x1, -0x19(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x5c2f
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3710
jmp 0x5c4b
jmp 0x5b33
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x5c60
movq %rax, -0x88(%rbp)
jmp 0x5b4d
movq -0x88(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rax, -0x38(%rbp)
cmpq 0x28(%rcx), %rax
je 0x5bec
movq -0x70(%rbp), %rdi
movq 0x20(%rdi), %rsi
movq -0x38(%rbp), %rdx
callq 0x5ca0
movq %rdx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x5b87
movq -0x98(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3690
testb $0x1, %al
jne 0x5bbb
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6210
jmp 0x5bb9
jmp 0x5bbb
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rax
movq -0x38(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
callq 0x6280
cmpq -0x18(%rbp), %rax
jb 0x5be7
movb $0x1, -0x19(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x5c2f
jmp 0x5b33
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq 0x20(%rax), %rax
subq %rax, %rdx
leaq -0x60(%rbp), %rdi
callq 0x5060
movq -0x70(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq 0x28(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x19(%rbp)
movl $0x1, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5c3e
movq -0x68(%rbp), %rdi
callq 0x3710
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::MakeCommentFreeLine(char*, char*)
std::string_view BufferedLineReader::MakeCommentFreeLine(char *first,
                                                         char *last) {
    if (remove_comments_) {
        char *start_of_comment = (char *)memchr(first, ';', last - first + 1);
        if (start_of_comment) last = start_of_comment - 1;
    }
    while (first <= last && isspace(*first)) first++;
    while (last >= first && isspace(*last)) last--;  // also removing newline
    if (last < first) return {};
    *++last = '\n';  // Fresh newline behind resulting new last.
    return std::string_view(first, last - first + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x5cf4
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
addq $0x1, %rdx
movl $0x3b, %esi
callq 0x2290
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5cf2
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5cf4
jmp 0x5cf6
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x31(%rbp)
ja 0x5d1a
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x2060
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5d23
jmp 0x5d31
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5cf6
jmp 0x5d33
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x32(%rbp)
jb 0x5d57
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x2060
cmpl $0x0, %eax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x5d60
jmp 0x5d6e
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5d33
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5d83
leaq -0x10(%rbp), %rdi
callq 0x3600
jmp 0x5db2
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0xa, 0x1(%rax)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
addq $0x1, %rdx
leaq -0x10(%rbp), %rdi
callq 0x5060
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
// File: hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::ReadLine()
std::string_view BufferedLineReader::ReadLine() {
    while (!is_eof()) {
        auto lines = ReadNextLines(1);
        if (lines.empty()) continue;  // could happen at buffer switchover
        return lines[0];
    }
    return {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3520
xorb $-0x1, %al
testb $0x1, %al
jne 0x5de5
jmp 0x5e47
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x1, %edx
callq 0x5aa0
leaq -0x30(%rbp), %rdi
callq 0x62a0
testb $0x1, %al
jne 0x5e06
jmp 0x5e0f
movl $0x2, -0x34(%rbp)
jmp 0x5e32
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x62e0
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3710
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x5e50
jmp 0x5e45
jmp 0x5dd4
leaq -0x10(%rbp), %rdi
callq 0x3600
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::area()
double Polygon::area()
{
  double res=0;
  for(int i=0;i<size();++i)
    res+=(poly[i].second.x()-poly[i].first.x())*(poly[i].first.y()+poly[i].second.y());
  return fabs(res)/2.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x2d10
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x1637
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
addq $0x8, %rdi
callq 0x13b0
movq -0x20(%rbp), %rdi
movss %xmm0, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13b0
movq -0x20(%rbp), %rdi
movaps %xmm0, %xmm1
movss -0x30(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13d0
movq -0x20(%rbp), %rdi
movss %xmm0, -0x2c(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
addq $0x8, %rdi
callq 0x13d0
movss -0x2c(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x28(%rbp), %xmm0
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1573
movsd -0x10(%rbp), %xmm0
movaps 0x69dd(%rip), %xmm1     # 0x8020
pand %xmm1, %xmm0
movsd 0x69b9(%rip), %xmm1     # 0x8008
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::isClosed()
bool Polygon::isClosed()
{
  bool res=true;
  for(int i=0;i<size()-1;++i)
    res &= (poly[i].second == poly[i+1].first);
  res &= (poly[size()-1].second == poly[0].first);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x2d10
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1cf2
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x2e10
movq -0x18(%rbp), %rdi
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2e10
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2e30
andb $0x1, %al
movzbl %al, %ecx
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c7f
movq -0x18(%rbp), %rdi
callq 0x2d10
movq -0x18(%rbp), %rdi
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2e10
movq -0x18(%rbp), %rdi
addq $0x8, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2e10
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2e30
andb $0x1, %al
movzbl %al, %ecx
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::isAcceptable(double)
bool Polygon::isAcceptable(double x)
{
  //return (area()/perimeter() > x); // notgood
  bool res;
  double w=width();
  if(w==0)
    res=false;
  else
  {
    res = (diameter()/w < x);
//    if(res)
//      std::cerr << diameter()/w << std::endl;
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1960
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1d89
jp 0x1d89
movb $0x0, -0x11(%rbp)
jmp 0x1dab
movq -0x28(%rbp), %rdi
callq 0x1660
movaps %xmm0, %xmm1
divsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::getBary()
Point Polygon::getBary()
{
  Point res(0,0);
  
  for(int i=0;i<size();++i)
  {
    res.x(res.x() + poly[i].first.x());
    res.y(res.y() + poly[i].first.y());
  }
  
  res.x(res.x()/size());
  res.y(res.y()/size());

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2e80
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x2d10
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x1e8b
movq -0x30(%rbp), %rdi
callq 0x13b0
movq -0x20(%rbp), %rdi
movss %xmm0, -0x3c(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13b0
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movss -0x3c(%rbp), %xmm0
addss %xmm1, %xmm0
callq 0x2eb0
movq -0x30(%rbp), %rdi
callq 0x13d0
movq -0x20(%rbp), %rdi
movss %xmm0, -0x38(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13d0
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movss -0x38(%rbp), %xmm0
addss %xmm1, %xmm0
callq 0x2ed0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1df5
movq -0x30(%rbp), %rdi
callq 0x13b0
movq -0x20(%rbp), %rdi
movss %xmm0, -0x44(%rbp)
callq 0x2d10
movss -0x44(%rbp), %xmm0
movq -0x30(%rbp), %rdi
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
callq 0x2eb0
movq -0x30(%rbp), %rdi
callq 0x13d0
movq -0x20(%rbp), %rdi
movss %xmm0, -0x40(%rbp)
callq 0x2d10
movss -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rdi
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
callq 0x2ed0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::randPoint()
std::pair<int,Point> Polygon::randPoint()
{
  Point res(0,0);
  
  int rEdge = rand()%size();
  double t=((double)rand()/(double)RAND_MAX);
  
  res.x(poly[rEdge].first.x() + t*(poly[rEdge].second.x() - poly[rEdge].first.x()));
  res.y(poly[rEdge].first.y() + t*(poly[rEdge].second.y() - poly[rEdge].first.y()));

  return std::pair<int,Point>(rEdge,res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2e80
callq 0x1030
movq -0x58(%rbp), %rdi
movl %eax, -0x70(%rbp)
callq 0x2d10
movl %eax, %ecx
movl -0x70(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
callq 0x1030
movq -0x58(%rbp), %rdi
cvtsi2sd %eax, %xmm0
movsd 0x60c5(%rip), %xmm1     # 0x8018
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13b0
movq -0x58(%rbp), %rdi
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
addq $0x8, %rdi
callq 0x13b0
movq -0x58(%rbp), %rdi
movss %xmm0, -0x6c(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13b0
movss -0x6c(%rbp), %xmm2
movsd -0x68(%rbp), %xmm1
movaps %xmm0, %xmm3
movsd -0x60(%rbp), %xmm0
subss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
leaq -0x18(%rbp), %rdi
callq 0x2eb0
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13d0
movq -0x58(%rbp), %rdi
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
addq $0x8, %rdi
callq 0x13d0
movq -0x58(%rbp), %rdi
movss %xmm0, -0x4c(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x2e10
movq %rax, %rdi
callq 0x13d0
movss -0x4c(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
subss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
leaq -0x18(%rbp), %rdi
callq 0x2ed0
movq -0x38(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x2ef0
movq -0x30(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: operator<<(std::ostream&, Polygon&)
std::ostream & operator<<(std::ostream & out, Polygon & p)
{
  //gnuplotstyle
  for(int i=0;i<p.size();++i)
  {
    Point f=p[i].first;
    Point s=p[i].second;
    out << f << std::endl << s << std::endl << std::endl;
  }
  
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d10
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jge 0x2ce5
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x2c(%rbp), %rdi
callq 0x2d60
leaq -0x2c(%rbp), %rsi
leaq -0x1c(%rbp), %rdi
callq 0x3050
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x44(%rbp), %rdi
callq 0x2d60
leaq -0x44(%rbp), %rsi
addq $0x8, %rsi
leaq -0x34(%rbp), %rdi
callq 0x3050
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1350
movq %rax, %rdi
movq 0xa318(%rip), %rsi      # 0xcfc0
callq 0x1120
movq %rax, %rdi
leaq -0x34(%rbp), %rsi
callq 0x1350
movq %rax, %rdi
movq 0xa2fd(%rip), %rsi      # 0xcfc0
callq 0x1120
movq %rax, %rdi
movq 0xa2ee(%rip), %rsi      # 0xcfc0
callq 0x1120
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c37
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Hybryd[P]HyRoadGenerator/main.cpp
// Function: density(double, double)
double density(double x,double y)
{
  // Gaussian centered on (x0,y0), of meansquare value sig.
  double x0=2;
  double y0=2;
  double sig=18;
  return (exp(-((x-x0)*(x-x0) + (y-y0)*(y-y0))/sig)*0.98);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x3ece(%rip), %xmm0     # 0x8008
movsd %xmm0, -0x18(%rbp)
movsd 0x3ec1(%rip), %xmm0     # 0x8008
movsd %xmm0, -0x20(%rbp)
movsd 0x3f1c(%rip), %xmm0     # 0x8070
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd -0x8(%rbp), %xmm2
subsd -0x18(%rbp), %xmm2
movsd -0x10(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm3
subsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd -0x28(%rbp), %xmm0
callq 0x1180
movsd 0x3eb2(%rip), %xmm1     # 0x8068
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: yanlinlin82[P]jsonxx/demo.new.cpp
// Function: main
int main()
{
	std::cout << std::unitbuf; // set no buffer for stdout
	test_constructors();
	test_json_node_values();
	test_assignments();
	test_append();
	test_parser();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x14062(%rip), %rdi     # 0x1bfd8
leaq 0x1a23(%rip), %rsi      # 0x99a0
callq 0x30f0
callq 0x38c0
callq 0x48f0
callq 0x4cd0
callq 0x5e90
callq 0x75b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: int yll::json::as_number<int>() const
T as_number() const {
			assert(type_ == type::number);
			std::istringstream ss(text_);
			T v;
			ss >> v;
			return v;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1a8(%rbp)
cmpl $0x2, (%rax)
jne 0x8bc1
jmp 0x8be0
leaq 0xc11d(%rip), %rdi      # 0x14ce5
leaq 0xbf5d(%rip), %rsi      # 0x14b2c
movl $0x45, %edx
leaq 0xc120(%rip), %rcx      # 0x14cfb
callq 0x3200
movq -0x1a8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
movl $0x8, %edx
callq 0x34c0
movq -0x1b0(%rbp), %rdi
leaq -0x18c(%rbp), %rsi
callq 0x31c0
jmp 0x8c18
movl -0x18c(%rbp), %eax
movl %eax, -0x1b4(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3170
movl -0x1b4(%rbp), %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3170
movq -0x198(%rbp), %rdi
callq 0x34e0
nopl (%rax)
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::append(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, yll::json const&)
json& append(const std::string& name, const json& x) {
			if (this == &x) {
				json copy(x);
				return append(name, copy);
			}
			if (type_ != type::object) { clear(type::object); }
			if (object_.find(name) == object_.end()) { array_.push_back(json(name)); }
			object_[name] = x;
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x932e
movq -0x20(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xa790
movq -0x1c0(%rbp), %rdi
movq -0x1d0(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x9290
movq %rax, -0x1c8(%rbp)
jmp 0x92ef
movq -0x1c8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x8b00
jmp 0x9519
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x8b00
jmp 0x9526
movq -0x1c0(%rbp), %rax
cmpl $0x5, (%rax)
je 0x93e4
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x34f0
movq -0x1d8(%rbp), %rdx
leaq 0xb985(%rip), %rsi      # 0x14ce4
leaq -0xc0(%rbp), %rdi
callq 0x7fb0
jmp 0x936d
movq -0x1c0(%rbp), %rdi
movl $0x5, %esi
leaq -0xc0(%rbp), %rdx
callq 0x10830
jmp 0x9387
leaq -0xc0(%rbp), %rdi
callq 0x3578
leaq -0xc1(%rbp), %rdi
callq 0x33a0
jmp 0x93e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x93d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x3578
leaq -0xc1(%rbp), %rdi
callq 0x33a0
jmp 0x9526
movq -0x1c0(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0xe890
movq -0x1c0(%rbp), %rdi
movq %rax, -0xd0(%rbp)
addq $0x40, %rdi
callq 0xe8c0
movq %rax, -0xd8(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xdf90
testb $0x1, %al
jne 0x942f
jmp 0x949e
movq -0x1c0(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x1e8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x148(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x8450
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0xe8f0
jmp 0x946d
leaq -0x148(%rbp), %rdi
callq 0x8b00
jmp 0x949e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x8b00
jmp 0x9526
movq -0x20(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
callq 0xa790
movq -0x1c0(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x10890
movq %rax, -0x1f0(%rbp)
jmp 0x94cb
movq -0x1f0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x8db0
jmp 0x94e0
leaq -0x1b8(%rbp), %rdi
callq 0x8b00
movq -0x1c0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9519
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x8b00
jmp 0x9526
movq -0x8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long*, bool)
bool parse(const std::string& text, size_t* pos = nullptr, bool strict = true) {
			const char* p = text.c_str();
			if (!parse_value(p, *this, strict)) {
				if (pos) *pos = p - text.c_str();
				return false;
			}
			skip_spaces(p);
			if (pos) *pos = p - text.c_str();
			return (!*p);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3130
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movb -0x21(%rbp), %al
leaq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x11840
testb $0x1, %al
jne 0x9955
cmpq $0x0, -0x20(%rbp)
je 0x994f
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3130
movq -0x40(%rbp), %rcx
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x9995
leaq -0x30(%rbp), %rdi
callq 0x11b60
cmpq $0x0, -0x20(%rbp)
je 0x9984
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3130
movq -0x48(%rbp), %rcx
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::trim0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::string trim0(std::string s) {
			if (s.find('.') != std::string::npos) {
				s.erase(s.find_last_not_of('0') + 1, std::string::npos);
				s.erase(s.find_last_not_of('.') + 1, std::string::npos);
			}
			return s;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x2e, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3430
cmpq $-0x1, %rax
je 0xca62
movq -0x28(%rbp), %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x3210
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x30a0
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x3210
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x30a0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x31b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::swap(yll::json&)
void swap(json& j) {
			using std::swap;
			swap(type_, j.type_);
			swap(text_, j.text_);
			swap(array_, j.array_);
			swap(object_, j.object_);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xe0e0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xe110
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0xe140
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0xe170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::clear(yll::json::type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void clear(type t = type::null, const std::string s = "") {
			type_ = t;
			text_ = s;
			array_.clear();
			object_.clear();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x28(%rbp)
movl %esi, %eax
movq -0x28(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
callq 0x3050
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x10970
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x10990
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::skip_spaces(char const*&)
static void skip_spaces(const char*& s) {
			while (*s) {
				if (isspace(*s)) {
					++s;
				} else if (*s == '/' && *(s + 1) == '*') { // Skip comments
					s += 2;
					while (*s) {
						if (*s == '*' && *(s + 1) == '/') {
							s += 2;
							break;
						}
						++s;
					}
				} else {
					break;
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x11c23
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x3060
cmpl $0x0, %eax
je 0x11ba0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x11c1e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x11c1a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2a, %eax
jne 0x11c1a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x11c18
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x11c08
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x11c08
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x11c18
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x11bcd
jmp 0x11c1c
jmp 0x11c23
jmp 0x11c1e
jmp 0x11b6c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)