LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: guoxuanhan[P]NetServer/timer.cpp
// Function: Timer::Adjust(int, Timer::TimerType, std::function<void ()> const&)
void Timer::Adjust(int timeout, Timer::TimerType timertype, const CallBack &timercallback)
{
    timeout_ = timeout;
    timertype_ = timertype;
    timercallback_ = timercallback;
    TimerManager::GetTimerManagerInstance()->AdjustTimer(this);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rdi)
movq 0x10(%rsp), %rsi
addq $0x8, %rdi
callq 0x5f40
callq 0x260d0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x26540
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::GetTimerManagerInstance()
TimerManager* TimerManager::GetTimerManagerInstance()
{
    if(ptimermanager_ == nullptr) //指针为空，则创建管理器
    {
        std::lock_guard<std::mutex> lock(mutex_);
        if(ptimermanager_ == nullptr) //双重检测
        {
            ptimermanager_ = new TimerManager();
        }
    }
    return ptimermanager_;
}

// Assembly:
subq $0x28, %rsp
cmpq $0x0, 0x1530c(%rip)     # 0x3b3e8
jne 0x2616a
leaq 0x20(%rsp), %rdi
leaq 0x15302(%rip), %rsi     # 0x3b3f0
callq 0x8c20
cmpq $0x0, 0x152ed(%rip)     # 0x3b3e8
jne 0x26152
movl $0x58, %edi
callq 0x53c0
movq %rax, 0x8(%rsp)
jmp 0x2610e
movq 0x8(%rsp), %rdi
callq 0x25f80
jmp 0x2611a
movq 0x8(%rsp), %rax
movq %rax, 0x152c2(%rip)     # 0x3b3e8
jmp 0x26152
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x2615e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x5370
jmp 0x2615e
leaq 0x20(%rsp), %rdi
callq 0x8cc0
jmp 0x2616a
leaq 0x20(%rsp), %rdi
callq 0x8cc0
jmp 0x26176
movq 0x15277(%rip), %rax     # 0x3b3e8
addq $0x28, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5660
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::AddTimer(Timer*)
void TimerManager::AddTimer(Timer* ptimer)
{
    if(ptimer == nullptr)
        return;
    std::lock_guard<std::mutex> lock(timewheelmutex_);
    CalculateTimer(ptimer);
    AddTimerToTimeWheel(ptimer);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x261a2
jmp 0x261e1
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
leaq 0x20(%rsp), %rdi
callq 0x8c20
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x26210
jmp 0x261c6
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x262a0
jmp 0x261d7
leaq 0x20(%rsp), %rdi
callq 0x8cc0
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8cc0
movq 0x18(%rsp), %rdi
callq 0x5660
nopl (%rax,%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::CalculateTimer(Timer*)
void TimerManager::CalculateTimer(Timer* ptimer)
{
    if(ptimer == nullptr)
        return;

    int tick = 0;
    int timeout = ptimer->timeout_;
    if(timeout < slotinterval)
    {
        tick = 1; //不足一个slot间隔，按延迟1slot计算
    }
    else
    {
        tick = timeout / slotinterval;
    }

    ptimer->rotation = tick / slotnum;
    int timeslot = (currentslot + tick) % slotnum;
    ptimer->timeslot = timeslot;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x2622e
jmp 0x2629b
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rsp)
cmpl $0x1, -0x18(%rsp)
jge 0x26252
movl $0x1, -0x14(%rsp)
jmp 0x26262
movl -0x18(%rsp), %eax
movl $0x1, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %eax, %edx
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
movl %edx, 0x28(%rcx)
movl (%rax), %eax
addl -0x14(%rsp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %edx, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x2c(%rax)
retq
nopl (%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::AddTimerToTimeWheel(Timer*)
void TimerManager::AddTimerToTimeWheel(Timer* ptimer)
{
    if(ptimer == nullptr)
        return;

    int timeslot = ptimer->timeslot;

    if(timewheel[timeslot])
    {
        ptimer->next = timewheel[timeslot];
        timewheel[timeslot]->prev = ptimer;
        timewheel[timeslot] = ptimer;
    }
    else
    {
        timewheel[timeslot] = ptimer;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x262c5
jmp 0x2637c
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x24(%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x26b00
cmpq $0x0, (%rax)
je 0x26359
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x26b00
movq 0x18(%rsp), %rdi
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x26b00
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x26b00
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2637c
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x26b00
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::RemoveTimer(Timer*)
void TimerManager::RemoveTimer(Timer* ptimer)
{
    if(ptimer == nullptr)
        return;
    std::lock_guard<std::mutex> lock(timewheelmutex_);
    RemoveTimerFromTimeWheel(ptimer);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x263b2
jmp 0x263e0
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
leaq 0x20(%rsp), %rdi
callq 0x8c20
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x26410
jmp 0x263d6
leaq 0x20(%rsp), %rdi
callq 0x8cc0
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8cc0
movq 0x18(%rsp), %rdi
callq 0x5660
nopw (%rax,%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::RemoveTimerFromTimeWheel(Timer*)
void TimerManager::RemoveTimerFromTimeWheel(Timer* ptimer)
{
    if(ptimer == nullptr)
        return;

    int timeslot = ptimer->timeslot;

    if(ptimer == timewheel[timeslot])
    {
        //头结点
        timewheel[timeslot] = ptimer->next;
        if(ptimer->next != nullptr)
        {
            ptimer->next->prev = nullptr;
        }
        ptimer->prev = ptimer->next = nullptr;
    }
    else
    {
        if(ptimer->prev == nullptr) //不在时间轮的链表中，即已经被删除了
            return;
        ptimer->prev->next = ptimer->next;
        if(ptimer->next != nullptr)
            ptimer->next->prev = ptimer->prev;

        ptimer->prev = ptimer->next = nullptr;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x26435
jmp 0x2652d
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x26b00
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq (%rcx), %rax
jne 0x264cd
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x26b00
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x264b1
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq $0x0, 0x30(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x30(%rax)
jmp 0x2652d
movq 0x28(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x264db
jmp 0x2652d
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x26513
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x30(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::AdjustTimer(Timer*)
void TimerManager::AdjustTimer(Timer* ptimer)
{
    if(ptimer == nullptr)
        return;

    std::lock_guard<std::mutex> lock(timewheelmutex_);
    AdjustTimerToWheel(ptimer);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x26562
jmp 0x26590
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
leaq 0x20(%rsp), %rdi
callq 0x8c20
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x265c0
jmp 0x26586
leaq 0x20(%rsp), %rdi
callq 0x8cc0
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8cc0
movq 0x18(%rsp), %rdi
callq 0x5660
nopw (%rax,%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::AdjustTimerToWheel(Timer*)
void TimerManager::AdjustTimerToWheel(Timer* ptimer)
{
    if(ptimer == nullptr)
        return;

    RemoveTimerFromTimeWheel(ptimer);
    CalculateTimer(ptimer);
    AddTimerToTimeWheel(ptimer);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x265e1
jmp 0x2660b
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x26410
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x26210
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x262a0
addq $0x18, %rsp
retq
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::CheckTimer()
void TimerManager::CheckTimer()//执行当前slot的任务
{
    std::lock_guard<std::mutex> lock(timewheelmutex_);
    Timer *ptimer = timewheel[currentslot];
    while(ptimer != nullptr)
    {
        if(ptimer->rotation > 0)
        {
            --ptimer->rotation;
            ptimer = ptimer->next;
        }
        else
        {
            //可执行定时器任务
            ptimer->timercallback_(); //注意：任务里不能把定时器自身给清理掉！！！我认为应该先移除再执行任务
            if(ptimer->timertype_ == Timer::TimerType::TIMER_ONCE)
            {
                Timer *ptemptimer = ptimer;
                ptimer = ptimer->next;
                RemoveTimerFromTimeWheel(ptemptimer);
            }
            else
            {
                Timer *ptemptimer = ptimer;
                ptimer = ptimer->next;
                AdjustTimerToWheel(ptemptimer);
                if(currentslot == ptemptimer->timeslot && ptemptimer->rotation > 0)
                {
                    //如果定时器多于一转的话，需要先对rotation减1，否则会等待两个周期
                    --ptemptimer->rotation;
                }
            }
        }
    }
    currentslot = (++currentslot) % TimerManager::slotnum; //移动至下一个时间槽
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x20, %rsi
leaq 0x38(%rsp), %rdi
callq 0x8c20
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq (%rax), %rsi
callq 0x26b00
movq (%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x26740
movq 0x30(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jle 0x26685
movq 0x30(%rsp), %rax
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x2673b
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x5f00
jmp 0x26695
movq 0x30(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x266e6
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rsi
callq 0x26410
jmp 0x26739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8cc0
jmp 0x2676a
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rsi
callq 0x265c0
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x2c(%rcx), %eax
jne 0x26737
movq 0x10(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jle 0x26737
movq 0x10(%rsp), %rax
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x26739
jmp 0x2673b
jmp 0x2664d
movq 0x8(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movq 0x8(%rsp), %rax
movl %edx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x8cc0
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
// File: guoxuanhan[P]NetServer/timermanager.cpp
// Function: TimerManager::CheckTick()
void TimerManager::CheckTick()
{
    // steady_clock::time_point t1 = steady_clock::now();
    // steady_clock::time_point t2 = steady_clock::now();
    // duration<double> time_span;
    int si = TimerManager::slotinterval;
    struct timeval tv;
    gettimeofday(&tv, NULL);
    int oldtime = (tv.tv_sec % 10000) * 1000 + tv.tv_usec / 1000;
    int time;
    int tickcount;
    while(running_)
    {
        gettimeofday(&tv, NULL);
        time = (tv.tv_sec % 10000) * 1000 + tv.tv_usec / 1000;
        tickcount = (time - oldtime)/slotinterval; //计算两次check的时间间隔占多少个slot
        //oldtime = time;
        oldtime = oldtime + tickcount*slotinterval;

        for(int i = 0; i < tickcount; ++i)
        {
            TimerManager::GetTimerManagerInstance()->CheckTimer();
        }
        std::this_thread::sleep_for(std::chrono::microseconds(500)); //milliseconds(si)时间粒度越小，延时越不精确，因为上下文切换耗时
        // t2 = steady_clock::now();
        // time_span = duration_cast<duration<double>>(t2 - t1);
        // t1 = t2;
        // std::cout << "thread " << time_span.count() << " seconds." << std::endl;
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x4c(%rsp)
leaq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55c0
movq 0x38(%rsp), %rax
movl $0x2710, %ecx           # imm = 0x2710
cqto
idivq %rcx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x34(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x48(%rax)
je 0x268ad
leaq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55c0
movq 0x38(%rsp), %rax
movl $0x2710, %ecx           # imm = 0x2710
cqto
idivq %rcx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
subl 0x34(%rsp), %eax
movl $0x1, %ecx
cltd
idivl %ecx
movl %eax, 0x2c(%rsp)
movl 0x34(%rsp), %eax
movl 0x2c(%rsp), %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl %eax, 0x34(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x26887
callq 0x260d0
movq %rax, %rdi
callq 0x26610
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x26863
movl $0x1f4, 0x1c(%rsp)      # imm = 0x1F4
leaq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x26bf0
leaq 0x20(%rsp), %rdi
callq 0x26b20
jmp 0x267e2
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: bonetblai[P]mdp-engine/race/./race.h
// Function: state_t::operator=(state_t const&)
const state_t& operator=(const state_t &s) {
        x_ = s.x_;
        y_ = s.y_;
        dx_ = s.dx_;
        dy_ = s.dy_;
        return *this;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq -0x10(%rsp), %rcx
movw 0x2(%rcx), %cx
movw %cx, 0x2(%rax)
movq -0x10(%rsp), %rcx
movw 0x4(%rcx), %cx
movw %cx, 0x4(%rax)
movq -0x10(%rsp), %rcx
movw 0x6(%rcx), %cx
movw %cx, 0x6(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/race/./race.h
// Function: state_t::operator<(state_t const&) const
bool operator<(const state_t &s) const {
        return (x_ < s.x_) ||
               ((x_ == s.x_) && (y_ < s.y_)) ||
               ((x_ == s.x_) && (y_ == s.y_) && (dx_ < s.dx_)) ||
               ((x_ == s.x_) && (y_ == s.y_) && (dx_ == s.dx_) && (dy_ < s.dy_));
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movswl (%rax), %ecx
movq -0x10(%rsp), %rax
movswl (%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x11(%rsp)
jl 0x511cc
movq -0x20(%rsp), %rax
movswl (%rax), %eax
movq -0x10(%rsp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x51111
movq -0x20(%rsp), %rax
movswl 0x2(%rax), %ecx
movq -0x10(%rsp), %rax
movswl 0x2(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x11(%rsp)
jl 0x511cc
movq -0x20(%rsp), %rax
movswl (%rax), %eax
movq -0x10(%rsp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x51157
movq -0x20(%rsp), %rax
movswl 0x2(%rax), %eax
movq -0x10(%rsp), %rcx
movswl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x51157
movq -0x20(%rsp), %rax
movswl 0x4(%rax), %ecx
movq -0x10(%rsp), %rax
movswl 0x4(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x11(%rsp)
jl 0x511cc
movq -0x20(%rsp), %rax
movswl (%rax), %ecx
movq -0x10(%rsp), %rax
movswl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rsp)
jne 0x511c4
movq -0x20(%rsp), %rax
movswl 0x2(%rax), %ecx
movq -0x10(%rsp), %rax
movswl 0x2(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rsp)
jne 0x511c4
movq -0x20(%rsp), %rax
movswl 0x4(%rax), %ecx
movq -0x10(%rsp), %rax
movswl 0x4(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rsp)
jne 0x511c4
movq -0x20(%rsp), %rax
movswl 0x6(%rax), %eax
movq -0x10(%rsp), %rcx
movswl 0x6(%rcx), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/race/parsing.cc
// Function: ps::header(std::ostream&, unsigned long, unsigned long)
void header(ostream &os, size_t rows, size_t cols) {
    os << "%!PS-Adobe-2.0 EPSF-1.2" << endl
       << "%%Creator: unknown" << endl
       << "%%DocumentFonts:" << endl
       << "%%Pages: 1" << endl
       << "%%BoundingBox: 0 0 " << (cols+2)*BOXW << " " << (rows+2)*BOXW << endl
       << "%%EndComments" << endl
       << "%%EndProlog" << endl
       << "%%Page: 1 1" << endl
       << "0 setlinewidth " << BOXW << " " << BOXW << " translate" << endl;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
leaq 0x57aa(%rip), %rsi      # 0x58c58
callq 0x62f0
movq %rax, %rdi
movq 0x23afb(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x57a4(%rip), %rsi      # 0x58c70
callq 0x62f0
movq %rax, %rdi
movq 0x23add(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5799(%rip), %rsi      # 0x58c83
callq 0x62f0
movq %rax, %rdi
movq 0x23abf(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x578c(%rip), %rsi      # 0x58c94
callq 0x62f0
movq %rax, %rdi
movq 0x23aa1(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5779(%rip), %rsi      # 0x58c9f
callq 0x62f0
movq %rax, %rdi
movq (%rsp), %rax
addq $0x2, %rax
imulq $0xa, %rax, %rsi
callq 0x60a0
movq %rax, %rdi
leaq 0x5955(%rip), %rsi      # 0x58e9e
callq 0x62f0
movq %rax, %rdi
movq 0x8(%rsp), %rax
addq $0x2, %rax
imulq $0xa, %rax, %rsi
callq 0x60a0
movq %rax, %rdi
movq 0x23a4b(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5737(%rip), %rsi      # 0x58cb3
callq 0x62f0
movq %rax, %rdi
movq 0x23a2d(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5727(%rip), %rsi      # 0x58cc1
callq 0x62f0
movq %rax, %rdi
movq 0x23a0f(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5715(%rip), %rsi      # 0x58ccd
callq 0x62f0
movq %rax, %rdi
movq 0x239f1(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5703(%rip), %rsi      # 0x58cd9
callq 0x62f0
movq %rax, %rdi
movl $0xa, %esi
callq 0x6520
movq %rax, %rdi
leaq 0x58ac(%rip), %rsi      # 0x58e9e
callq 0x62f0
movq %rax, %rdi
movl $0xa, %esi
callq 0x6520
movq %rax, %rdi
leaq 0x56db(%rip), %rsi      # 0x58ce9
callq 0x62f0
movq %rax, %rdi
movq 0x2399b(%rip), %rsi     # 0x76fb8
callq 0x6340
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: bonetblai[P]mdp-engine/race/parsing.cc
// Function: ps::draw_filled_rectangle(std::ostream&, int, int, int, int, int, int, int)
void draw_filled_rectangle(ostream &os, int x, int y, int dx, int dy, int r, int g, int b) {
    os << r << " " << g << " " << b << " setrgbcolor" << endl
       << "newpath " << x << " " << y << " moveto "
       << dx << " 0 rlineto 0 " << dy << " rlineto "
       << -dx << " 0 rlineto closepath fill" << endl
       << "0 0 0 setrgbcolor" << endl
       << "newpath " << x << " " << y << " moveto "
       << dx << " 0 rlineto 0 " << dy << " rlineto " << -dx
       << " 0 rlineto closepath stroke" << endl;
}

// Assembly:
subq $0x28, %rsp
movl 0x38(%rsp), %eax
movl 0x30(%rsp), %eax
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x57ff(%rip), %rsi      # 0x58e9e
callq 0x62f0
movq %rax, %rdi
movl 0x30(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x57e4(%rip), %rsi      # 0x58e9e
callq 0x62f0
movq %rax, %rdi
movl 0x38(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x566e(%rip), %rsi      # 0x58d43
callq 0x62f0
movq %rax, %rdi
movq 0x238d4(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5607(%rip), %rsi      # 0x58cfa
callq 0x62f0
movq %rax, %rdi
movl 0x1c(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x5790(%rip), %rsi      # 0x58e9e
callq 0x62f0
movq %rax, %rdi
movl 0x18(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x55da(%rip), %rsi      # 0x58d03
callq 0x62f0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x55c8(%rip), %rsi      # 0x58d0c
callq 0x62f0
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x55bb(%rip), %rsi      # 0x58d1a
callq 0x62f0
movq %rax, %rdi
xorl %esi, %esi
subl 0x14(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x55a8(%rip), %rsi      # 0x58d24
callq 0x62f0
movq %rax, %rdi
movq 0x2382d(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x55a4(%rip), %rsi      # 0x58d3e
callq 0x62f0
movq %rax, %rdi
movq 0x2380f(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5542(%rip), %rsi      # 0x58cfa
callq 0x62f0
movq %rax, %rdi
movl 0x1c(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x56cb(%rip), %rsi      # 0x58e9e
callq 0x62f0
movq %rax, %rdi
movl 0x18(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x5515(%rip), %rsi      # 0x58d03
callq 0x62f0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x5503(%rip), %rsi      # 0x58d0c
callq 0x62f0
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x54f6(%rip), %rsi      # 0x58d1a
callq 0x62f0
movq %rax, %rdi
xorl %esi, %esi
subl 0x14(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x550f(%rip), %rsi      # 0x58d50
callq 0x62f0
movq %rax, %rdi
movq 0x23768(%rip), %rsi     # 0x76fb8
callq 0x6340
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: bonetblai[P]mdp-engine/race/parsing.cc
// Function: ps::draw_text(std::ostream&, float, float, float, int, char*)
void draw_text(ostream &os, float x, float y, float angle, int ptsz, char *text) {
    os << "0 0 0 setrgbcolor" << endl
       << "/Helvetica " << ptsz << " selectfont" << endl
       << x << " " << y << " moveto " << angle << " rotate" << endl
       << "(" << text << ") show" << endl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movss %xmm1, 0x18(%rsp)
movss %xmm2, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x53de(%rip), %rsi      # 0x58d3e
callq 0x62f0
movq %rax, %rdi
movq 0x23649(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x5438(%rip), %rsi      # 0x58db6
callq 0x62f0
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x6520
movq %rax, %rdi
leaq 0x5429(%rip), %rsi      # 0x58dc2
callq 0x62f0
movq %rax, %rdi
movq 0x23610(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
movss 0x1c(%rsp), %xmm0
callq 0x6210
movq %rax, %rdi
leaq 0x54d9(%rip), %rsi      # 0x58e9e
callq 0x62f0
movq %rax, %rdi
movss 0x18(%rsp), %xmm0
callq 0x6210
movq %rax, %rdi
leaq 0x5321(%rip), %rsi      # 0x58d03
callq 0x62f0
movq %rax, %rdi
movss 0x14(%rsp), %xmm0
callq 0x6210
movq %rax, %rdi
leaq 0x53cf(%rip), %rsi      # 0x58dce
callq 0x62f0
movq %rax, %rdi
movq 0x235aa(%rip), %rsi     # 0x76fb8
callq 0x6340
movq %rax, %rdi
leaq 0x2410(%rip), %rsi      # 0x55e2d
callq 0x62f0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x62f0
movq %rax, %rdi
leaq 0x539d(%rip), %rsi      # 0x58dd6
callq 0x62f0
movq %rax, %rdi
movq 0x23570(%rip), %rsi     # 0x76fb8
callq 0x6340
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: CalcPolygonLen(std::vector<Vector2D, std::allocator<Vector2D>> const&)
double CalcPolygonLen(const Polygon &polygon) {
  double len = 0;
  const int size = polygon.size();
  for (int i = 1; i < size; ++i) {
    len += distance(polygon[i].x - polygon[i-1].x,
                    polygon[i].y - polygon[i-1].y, 0);
  }
  // Back to the beginning.
  len += distance(polygon[size-1].x - polygon[0].x,
                  polygon[size-1].y - polygon[0].y, 0);
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x82d0
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x36b1
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x8340
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8340
movsd -0x30(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x8340
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8340
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
subsd 0x8(%rax), %xmm1
xorps %xmm2, %xmm2
callq 0x82f0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3617
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8340
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8340
movsd -0x48(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8340
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8340
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
subsd 0x8(%rax), %xmm1
xorps %xmm2, %xmm2
callq 0x82f0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: OffsetCenter(std::vector<Vector2D, std::allocator<Vector2D>> const&, double, double)
Polygon OffsetCenter(const Polygon& polygon, double x_offset, double y_offset) {
  Polygon result;
  for (const Vector2D &p : polygon) {
    result.push_back(Vector2D(p.x + x_offset, p.y + y_offset));
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x8360
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8380
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x83b0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x83e0
testb $0x1, %al
jne 0x37a6
jmp 0x3810
leaq -0x38(%rbp), %rdi
callq 0x8420
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsd -0x18(%rbp), %xmm2
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
addsd %xmm2, %xmm0
movsd -0x20(%rbp), %xmm2
addsd %xmm2, %xmm1
leaq -0x58(%rbp), %rdi
callq 0x8470
jmp 0x37dd
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8440
jmp 0x37ec
jmp 0x37ee
leaq -0x38(%rbp), %rdi
callq 0x84a0
jmp 0x3793
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x84c0
jmp 0x3830
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x3823
movq -0x78(%rbp), %rdi
callq 0x84c0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: RadialPumpPolygon(std::vector<Vector2D, std::allocator<Vector2D>> const&, double)
Polygon RadialPumpPolygon(const Polygon& polygon, double pump_r) {
  if (pump_r <= 0)
    return polygon;
  Polygon result;
  for (const Vector2D &p : polygon) {
    double from_center = distance(p.x, p.y, 0);
    double stretch = (from_center + pump_r) / from_center;
    result.push_back(Vector2D(p.x * stretch, p.y * stretch));
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0x3b7f
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x85b0
jmp 0x3c87
movq -0x80(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x8360
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8380
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x83b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x83e0
testb $0x1, %al
jne 0x3bc4
jmp 0x3c72
leaq -0x30(%rbp), %rdi
callq 0x8420
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
xorps %xmm2, %xmm2
callq 0x82f0
movsd %xmm0, -0x88(%rbp)
jmp 0x3bf0
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movaps %xmm1, %xmm0
addsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x40(%rbp), %rax
movsd -0x60(%rbp), %xmm2
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
leaq -0x70(%rbp), %rdi
callq 0x8470
jmp 0x3c3c
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8440
jmp 0x3c4b
jmp 0x3c4d
leaq -0x30(%rbp), %rdi
callq 0x84a0
jmp 0x3bae
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x84c0
jmp 0x3c94
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3c85
movq -0x80(%rbp), %rdi
callq 0x84c0
jmp 0x3c87
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: GetRadius(std::vector<Vector2D, std::allocator<Vector2D>> const&)
double GetRadius(const Polygon &polygon) {
  double dist = -1;
  for (size_t i = 0; i < polygon.size(); ++i) {
    dist = std::max(dist, distance(polygon[i].x, polygon[i].y, 0));
  }
  return dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd 0x27354(%rip), %xmm0    # 0x2b008
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x82d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3d3c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8340
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8340
movsd -0x30(%rbp), %xmm0
movsd 0x8(%rax), %xmm1
xorps %xmm2, %xmm2
callq 0x82f0
movsd %xmm0, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x86a0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3cc1
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/rotational-polygon.cc
// Function: (anonymous namespace)::PolarFunction::PolarFunction(char const*)
PolarFunction(const char *fun_init) {
      const unsigned char *init = (const unsigned char*) fun_init;
      int min = 0x100;
      int max = -1;
      for (const unsigned char *s = init; *s; ++s) {
        if (*s < min) min = *s;
        if (*s > max) max = *s;
      }
      double range = max - min;
      for (const unsigned char *s = init; *s; ++s) {
        if (range > 0)
          values_.push_back((*s - min) / range);
        else
          values_.push_back(0);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb690
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x100, -0x1c(%rbp)     # imm = 0x100
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb3e0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb3ba
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x20(%rbp), %eax
jle 0xb3d0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xb3d2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb39b
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb484
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb458
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd -0x30(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0xb6b0
jmp 0xb43f
jmp 0xb471
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xb6e0
jmp 0xb48a
movq -0x60(%rbp), %rdi
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0xb6b0
jmp 0xb46f
jmp 0xb471
jmp 0xb473
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xb3f7
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/rotational-polygon.cc
// Function: (anonymous namespace)::PolarFunction::value(double)
double value(double phi) {
      const int n = phi * values_.size();
      assert(n < (int) values_.size());
      // linear interpolation between this and the next value.
      const double a = values_[n];
      const double b = values_[(n+1) % values_.size()];
      double fraction = phi * values_.size() - n;
      return a + (b - a) * fraction;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0xbd30
movsd -0x48(%rbp), %xmm0
movq -0x40(%rbp), %rdi
movq %rax, %xmm1
movaps 0x209b3(%rip), %xmm2    # 0x2bec0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x209b7(%rip), %xmm2    # 0x2bed0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0xbd30
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0xb54a
jmp 0xb569
leaq 0x2098f(%rip), %rdi     # 0x2bee0
leaq 0x209a1(%rip), %rsi     # 0x2bef9
movl $0x25, %edx
leaq 0x209ab(%rip), %rcx     # 0x2bf0f
callq 0x3190
movq -0x40(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xc190
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
incl %eax
cltq
movq %rax, -0x58(%rbp)
callq 0xbd30
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x58(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0xc190
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0xbd30
movsd -0x50(%rbp), %xmm0
movq %rax, %xmm2
movaps 0x208e8(%rip), %xmm1    # 0x2bec0
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movapd 0x208ec(%rip), %xmm1    # 0x2bed0
subpd %xmm1, %xmm2
movaps %xmm2, %xmm1
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm1, %xmm2
cvtsi2sdl -0x14(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: hzeller[P]gcode-multi-shell-extrude/polygon-offset.cc
// Function: is_centered(Vector2D const&, std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>> const&)
static bool is_centered(const Vector2D &centroid, const ClipperLib::Path &path) {
  int min_x = INT_MAX, min_y = INT_MAX;
  int max_x = INT_MIN, max_y = INT_MIN;
  for (const ClipperLib::IntPoint &p : path) {
    if (p.X < min_x) min_x = p.X;
    if (p.X > max_x) max_x = p.X;
    if (p.Y < min_y) min_y = p.Y;
    if (p.Y > max_y) max_y = p.Y;
  }
  return (min_x < centroid.x && max_x > centroid.x
          && min_y < centroid.y && max_y > centroid.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x7fffffff, -0x14(%rbp) # imm = 0x7FFFFFFF
movl $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
movl $0x80000000, -0x1c(%rbp) # imm = 0x80000000
movl $0x80000000, -0x20(%rbp) # imm = 0x80000000
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd1b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd1e0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd210
testb $0x1, %al
jne 0xc994
jmp 0xca1d
leaq -0x30(%rbp), %rdi
callq 0xd250
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jge 0xc9bb
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x14(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
jle 0xc9d5
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jge 0xc9f1
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jle 0xca0d
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x20(%rbp)
jmp 0xca0f
leaq -0x30(%rbp), %rdi
callq 0xd270
jmp 0xc97e
cvtsi2sdl -0x14(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x41(%rbp)
jbe 0xca76
cvtsi2sdl -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
ucomisd (%rcx), %xmm0
movb %al, -0x41(%rbp)
jbe 0xca76
cvtsi2sdl -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x41(%rbp)
jbe 0xca76
cvtsi2sdl -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
seta %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::Postamble()
virtual void Postamble() {
    printf("M104 S0 ; hotend off\n");
    printf("M140 S0 ; heated bed off\n");
    printf("M106 S0 ; fan off\n");
    printf("G1 X0\n");  // We keep z-axis as is.
    printf("G92 E0.0\n");
    printf("M84\n");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1d673(%rip), %rdi     # 0x2c256
movb $0x0, %al
callq 0x3040
leaq 0x1d67b(%rip), %rdi     # 0x2c26c
movb $0x0, %al
callq 0x3040
leaq 0x1d687(%rip), %rdi     # 0x2c286
movb $0x0, %al
callq 0x3040
leaq 0x1d68c(%rip), %rdi     # 0x2c299
movb $0x0, %al
callq 0x3040
leaq 0x1d685(%rip), %rdi     # 0x2c2a0
movb $0x0, %al
callq 0x3040
leaq 0x1d681(%rip), %rdi     # 0x2c2aa
movb $0x0, %al
callq 0x3040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::SetSpeed(double)
virtual void SetSpeed(double feed_mm_per_sec) {
    if (feed_mm_per_sec != current_feedrate_) {
      printf("G1 F%.1f  ; feedrate=%.1fmm/s\n", feed_mm_per_sec * 60,
             feed_mm_per_sec);
      current_feedrate_ = feed_mm_per_sec;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd 0x18(%rax), %xmm0
jne 0xed69
jp 0xed69
jmp 0xed97
movsd 0x1d1f7(%rip), %xmm0    # 0x2bf68
mulsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
leaq 0x1d53c(%rip), %rdi     # 0x2c2be
movb $0x2, %al
callq 0x3040
movq -0x18(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::ResetExtrude()
virtual void ResetExtrude() {
    assert(in_retract_);
    in_retract_ = false;
    printf("M83      ; relative E\n"  // extruder relative mode
           "G1 E%.1f  ; filament back to nozzle tip\n"
           "M82      ; absolute E\n", // extruder absolute mode
           1.1 * retract_amount_);  // fudging... a bit more squeeze.
    printf("G92 E0.0 ; start extrusion, set E to zero\n");
    extrude_dist_ = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x50(%rax)
je 0xedbc
jmp 0xeddb
leaq 0x1d5e7(%rip), %rdi     # 0x2c3aa
leaq 0x1d513(%rip), %rsi     # 0x2c2dd
movl $0x76, %edx
leaq 0x1d512(%rip), %rcx     # 0x2c2e8
callq 0x3190
movq -0x10(%rbp), %rax
movb $0x0, 0x50(%rax)
movsd 0x1d1b5(%rip), %xmm0    # 0x2bfa0
mulsd 0x10(%rax), %xmm0
leaq 0x1d532(%rip), %rdi     # 0x2c329
movb $0x1, %al
callq 0x3040
leaq 0x1d579(%rip), %rdi     # 0x2c37e
movb $0x0, %al
callq 0x3040
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::Retract()
virtual void Retract() {
    assert(!in_retract_);
    printf("M83      ; relative E\n"
           "G1 E%.1f ; retract\n"
           "M82      ; Back to absolute\n", -retract_amount_);
    in_retract_ = true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb 0x50(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xee3f
jmp 0xee41
jmp 0xee60
leaq 0x1d561(%rip), %rdi     # 0x2c3a9
leaq 0x1d48e(%rip), %rsi     # 0x2c2dd
movl $0x80, %edx
leaq 0x1d55b(%rip), %rcx     # 0x2c3b6
callq 0x3190
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
leaq 0x1d56b(%rip), %rdi     # 0x2c3f2
movb $0x1, %al
callq 0x3040
movq -0x10(%rbp), %rax
movb $0x1, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::ExtrudeTo(Vector2D const&, double, double)
virtual void ExtrudeTo(const Vector2D &pos, double z,
                         double extrusion_multiplier) {
    extrude_dist_ += distance(pos.x - last_x, pos.y - last_y, z - last_z);
    printf("G1 X%.3f Y%.3f Z%.3f E%.3f\n", pos.x, pos.y, z,
           extrude_dist_ * filament_extrusion_factor_ * extrusion_multiplier);
    last_x = pos.x; last_y = pos.y; last_z = z;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
subsd 0x30(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
subsd 0x38(%rax), %xmm1
movsd -0x18(%rbp), %xmm2
subsd 0x40(%rax), %xmm2
callq 0x82f0
movq -0x28(%rbp), %rax
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movsd -0x18(%rbp), %xmm2
movsd 0x48(%rax), %xmm3
mulsd 0x8(%rax), %xmm3
mulsd -0x20(%rbp), %xmm3
leaq 0x1d492(%rip), %rdi     # 0x2c458
movb $0x4, %al
callq 0x3040
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::PostScriptPrinter::Init(Vector2D const&, double)
virtual void Init(const Vector2D &machine_limit,
                    double feed_mm_per_sec) {
    printf("/extrude-to { lineto } def\n");
    printf("72.0 25.4 div dup scale  %% Switch to mm\n");
    printf("1 setlinejoin\n");
    printf("%.2f setlinewidth %% mm\n", line_thickness_);
    printf("0 0 moveto\n");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1d3cb(%rip), %rdi     # 0x2c4af
movb $0x0, %al
callq 0x3040
leaq 0x1d3d9(%rip), %rdi     # 0x2c4cb
movb $0x0, %al
callq 0x3040
leaq 0x1d3f5(%rip), %rdi     # 0x2c4f5
movb $0x0, %al
callq 0x3040
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1d3e9(%rip), %rdi     # 0x2c504
movb $0x1, %al
callq 0x3040
leaq 0x1d3f4(%rip), %rdi     # 0x2c51d
movb $0x0, %al
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::PostScriptPrinter::MoveTo(Vector2D const&, double)
virtual void MoveTo(const Vector2D &pos, double z) {
    if (show_move_as_line_) {
      if (!in_move_color_) {
        ColorSwitch(0, 0, 0, 0.9);  // blue move color
        in_move_color_ = true;
      }
      printf("%.3f %.3f lineto\n", pos.x, pos.y);
    } else {
      printf("%.3f %.3f moveto\n", pos.x, pos.y);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x8(%rax)
je 0xf2e0
movq -0x20(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0xf2bf
movq -0x20(%rbp), %rdi
xorps %xmm2, %xmm2
movss 0x1bdec(%rip), %xmm3    # 0x2b098
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xf430
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
leaq 0x1d2ad(%rip), %rdi     # 0x2c584
movb $0x2, %al
callq 0x3040
jmp 0xf2ff
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
leaq 0x1d29e(%rip), %rdi     # 0x2c596
movb $0x2, %al
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::PostScriptPrinter::ExtrudeTo(Vector2D const&, double, double)
virtual void ExtrudeTo(const Vector2D &pos, double /*z*/,
                         double /*extrusion_multiplier*/) {
    if (in_move_color_) {
      ColorSwitch(line_thickness_, r_, g_, b_);
      in_move_color_ = false;
    }
    printf("%.3f %.3f extrude-to\n", pos.x, pos.y);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x10(%rax)
je 0xf35d
movq -0x28(%rbp), %rdi
movss 0xc(%rdi), %xmm0
movss 0x14(%rdi), %xmm1
movss 0x18(%rdi), %xmm2
movss 0x1c(%rdi), %xmm3
callq 0xf430
movq -0x28(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
leaq 0x1d27d(%rip), %rdi     # 0x2c5f2
movb $0x2, %al
callq 0x3040
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)