LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: hold_temp()
void hold_temp()
{
   if(lpt_addr) {  // we are using the parallel port to control temp
      lpt_val = (lpt_val & 0xF0) | 0x06;
      outp(lpt_addr, lpt_val);
   }
   else if(com[fan_port].com_port > 0) { // using serial port DTR line to control temp
      SetDtrLine(fan_port, COOL);
      SetRtsLine(fan_port, DISABLE);
   }
   send_fan_cmd("$HOLD");

   if(a_holding == 0) {
      hold_on_tick = GetMsecs(); 
   }
   a_holding = 1;
   a_heating = 0;
   a_cooling = 0;
   temp_dir = '=';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x234315(%rip), %rax    # 0x39efb0
cmpl $0x0, (%rax)
je 0x16acd7
leaq 0x23430d(%rip), %rax    # 0x39efb4
movzbl (%rax), %eax
andl $0xf0, %eax
orl $0x6, %eax
movb %al, %cl
leaq 0x2342f9(%rip), %rax    # 0x39efb4
movb %cl, (%rax)
leaq 0x2342ec(%rip), %rax    # 0x39efb0
movl (%rax), %edi
leaq 0x2342e7(%rip), %rax    # 0x39efb4
movzbl (%rax), %esi
callq 0xb650
jmp 0x16ad20
leaq 0x2027ce(%rip), %rax    # 0x36d4ac
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2027d7(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
cmpl $0x0, (%rax)
jle 0x16ad1e
leaq 0x2027ad(%rip), %rax    # 0x36d4ac
movl (%rax), %edi
movl $0x1, %esi
callq 0xb660
leaq 0x20279a(%rip), %rax    # 0x36d4ac
movl (%rax), %edi
movl $0x1, %esi
callq 0xb700
jmp 0x16ad20
leaq 0x2de44(%rip), %rdi     # 0x198b6b
callq 0x83980
movzbl 0x349ebf(%rip), %eax    # 0x4b4bf2
cmpl $0x0, %eax
jne 0x16ad45
callq 0xb630
movsd %xmm0, 0x349f0b(%rip)   # 0x4b4c50
movb $0x1, 0x349ea6(%rip)    # 0x4b4bf2
movb $0x0, 0x349e9d(%rip)    # 0x4b4bf0
movb $0x0, 0x349e97(%rip)    # 0x4b4bf1
leaq 0x201407(%rip), %rax    # 0x36c168
movb $0x3d, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: enable_temp_control()
void enable_temp_control()
{
   if(lpt_port) {  // get lpt port address from bios area
      lpt_addr = init_lpt();
   }
   else lpt_addr = 0;

   if(lpt_addr) {  // turn on parallel port temp control unit
      lpt_val = (lpt_val & 0x0F) | 0x90;
      outp(lpt_addr, lpt_val);
   }
   else if(com[fan_port].com_port > 0) { // using serial port lines to control temp
      SetRtsLine(fan_port, ENABLE);
   }
   send_fan_cmd("$INIT");

   low_ok = high_ok = 0;
   HEAT_OVERSHOOT = COOL_UNDERSHOOT = 0.0F;

   temp_control_on = 1;
   hold_temp();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x22b481(%rip), %rax    # 0x3961fc
cmpl $0x0, (%rax)
je 0x16ad92
callq 0x1693e0
movl %eax, %ecx
leaq 0x234222(%rip), %rax    # 0x39efb0
movl %ecx, (%rax)
jmp 0x16ad9f
leaq 0x234217(%rip), %rax    # 0x39efb0
movl $0x0, (%rax)
leaq 0x23420a(%rip), %rax    # 0x39efb0
cmpl $0x0, (%rax)
je 0x16ade2
leaq 0x234202(%rip), %rax    # 0x39efb4
movzbl (%rax), %eax
andl $0xf, %eax
orl $0x90, %eax
movb %al, %cl
leaq 0x2341ee(%rip), %rax    # 0x39efb4
movb %cl, (%rax)
leaq 0x2341e1(%rip), %rax    # 0x39efb0
movl (%rax), %edi
leaq 0x2341dc(%rip), %rax    # 0x39efb4
movzbl (%rax), %esi
callq 0xb650
jmp 0x16ae15
leaq 0x2026c3(%rip), %rax    # 0x36d4ac
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2026cc(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
cmpl $0x0, (%rax)
jle 0x16ae13
leaq 0x2026a2(%rip), %rax    # 0x36d4ac
movl (%rax), %edi
xorl %esi, %esi
callq 0xb700
jmp 0x16ae15
leaq 0x2dd55(%rip), %rdi     # 0x198b71
callq 0x83980
movq $0x0, 0x349eac(%rip) # 0x4b4cd8
movq $0x0, 0x349e99(%rip) # 0x4b4cd0
xorps %xmm0, %xmm0
movsd %xmm0, 0x349ea6(%rip)   # 0x4b4ce8
xorps %xmm0, %xmm0
movsd %xmm0, 0x349e93(%rip)   # 0x4b4ce0
leaq 0x23414d(%rip), %rax    # 0x39efa1
movb $0x1, (%rax)
callq 0x16ac90
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: disable_temp_control()
void disable_temp_control()
{
   if(temp_control_on == 0) return;

   hold_temp();
   if(lpt_addr) {  // using parallel port to control temp
      lpt_val = (lpt_val & 0x0F) | 0x60;
      outp(lpt_addr, lpt_val);
   }
   else if(com[fan_port].com_port > 0) { // using serial port to control temp
     SetRtsLine(fan_port, DISABLE);
   }
   send_fan_cmd("$STOP");

   temp_control_on = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x234136(%rip), %rax    # 0x39efa1
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x16ae78
jmp 0x16af0a
callq 0x16ac90
leaq 0x23412c(%rip), %rax    # 0x39efb0
cmpl $0x0, (%rax)
je 0x16aebe
leaq 0x234124(%rip), %rax    # 0x39efb4
movzbl (%rax), %eax
andl $0xf, %eax
orl $0x60, %eax
movb %al, %cl
leaq 0x234112(%rip), %rax    # 0x39efb4
movb %cl, (%rax)
leaq 0x234105(%rip), %rax    # 0x39efb0
movl (%rax), %edi
leaq 0x234100(%rip), %rax    # 0x39efb4
movzbl (%rax), %esi
callq 0xb650
jmp 0x16aef4
leaq 0x2025e7(%rip), %rax    # 0x36d4ac
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2025f0(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
cmpl $0x0, (%rax)
jle 0x16aef2
leaq 0x2025c6(%rip), %rax    # 0x36d4ac
movl (%rax), %edi
movl $0x1, %esi
callq 0xb700
jmp 0x16aef4
leaq 0x2dc7c(%rip), %rdi     # 0x198b77
callq 0x83980
leaq 0x23409a(%rip), %rax    # 0x39efa1
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: show_osc_pid_values()
void show_osc_pid_values()
{
   if(dac_dac) return;

   sprintf(plot_title, "bP(%.2f %c %.4f) bD(%.2f %c %.4f) bF(%.2f %c %.4f) bI(%.1f %c %.3f)  bO=%.3f bL=%.3f bS=%.3f bR=%.3f b9=%-3d", 
      OSC_P_GAIN,RIGHT_ARROW,osc_k1, 
      OSC_D_TC,RIGHT_ARROW,osc_k2, 
      OSC_FILTER_TC,RIGHT_ARROW,osc_k3, 
      OSC_I_TC,RIGHT_ARROW,osc_k4, 
      OSC_FILTER_OFFSET, osc_k6, osc_k7, osc_k8, osc_postfilter);
   title_type = OTHER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x22f7dd(%rip), %rax    # 0x39a9fc
cmpl $0x0, (%rax)
je 0x16b229
jmp 0x16b2f5
leaq 0x233650(%rip), %rax    # 0x39e880
movsd (%rax), %xmm0
movsd 0x349c0c(%rip), %xmm1   # 0x4b4e48
leaq 0x233645(%rip), %rax    # 0x39e888
movsd (%rax), %xmm2
movsd 0x349c01(%rip), %xmm3   # 0x4b4e50
leaq 0x23363a(%rip), %rax    # 0x39e890
movsd (%rax), %xmm4
movsd 0x349bf6(%rip), %xmm5   # 0x4b4e58
leaq 0x23362f(%rip), %rax    # 0x39e898
movsd (%rax), %xmm6
movsd 0x349beb(%rip), %xmm7   # 0x4b4e60
leaq 0x233624(%rip), %rax    # 0x39e8a0
movsd (%rax), %xmm11
movsd 0x349be6(%rip), %xmm10  # 0x4b4e70
movsd 0x349be5(%rip), %xmm9   # 0x4b4e78
movsd 0x349be4(%rip), %xmm8   # 0x4b4e80
leaq 0x2335c9(%rip), %rax    # 0x39e86c
movl (%rax), %eax
leaq 0x232784(%rip), %rdi    # 0x39da30
leaq 0x2d8ca(%rip), %rsi     # 0x198b7d
movl $0x1a, %r9d
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
movsd %xmm11, (%rsp)
movsd %xmm10, 0x8(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x8, %al
callq 0x9060
leaq 0x2331bd(%rip), %rax    # 0x39e4ac
movl $0x3, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: reset_osc_pid(int)
void reset_osc_pid(int kbd_cmd)
{
   disable_osc_control();

   osc_PID_out = 0.0;          // new filter output
   last_osc_PID_out = 0.0;     // previous filter output
   osc_PID_error = 0.0;        // new osc error
   last_osc_PID_error = 0.0;   // previous osc error
   last_osc_PID_display = 0.0; // previous PID filter value (for debug display)
   osc_integral_step = 0.0;    // integrator update factor
   osc_integrator = 0.0;       // integral value

   post_q_count = 0;
   new_postfilter();

// if(kbd_cmd) enable_osc_control(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x169390
xorps %xmm0, %xmm0
movsd %xmm0, 0x349af5(%rip)   # 0x4b4e10
xorps %xmm0, %xmm0
movsd %xmm0, 0x349af2(%rip)   # 0x4b4e18
xorps %xmm0, %xmm0
movsd %xmm0, 0x349aef(%rip)   # 0x4b4e20
xorps %xmm0, %xmm0
movsd %xmm0, 0x349aec(%rip)   # 0x4b4e28
xorps %xmm0, %xmm0
movsd %xmm0, 0x349ae9(%rip)   # 0x4b4e30
xorps %xmm0, %xmm0
movsd %xmm0, 0x349ae6(%rip)   # 0x4b4e38
xorps %xmm0, %xmm0
movsd %xmm0, 0x349ae3(%rip)   # 0x4b4e40
leaq 0x23350c(%rip), %rax    # 0x39e870
movl $0x0, (%rax)
callq 0x16b380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: new_postfilter()
void new_postfilter()
{
double post_val;
int i;

   if(1 || (osc_postfilter < post_q_count)) {  // changing filter size,  rebuild filter queue
      if(post_q_count) post_val = post_q_sum / (double) post_q_count;
      else             post_val = osc_PID_out;
      post_q_sum = 0.0;
      for(i=0; i<osc_postfilter; i++) {
         osc_post_q[i] = post_val;
         post_q_sum += post_val;
      }
      post_q_count = osc_postfilter;
      post_q_in = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2334e5(%rip), %rax    # 0x39e870
cmpl $0x0, (%rax)
je 0x16b3ae
movsd 0x34b1a0(%rip), %xmm0   # 0x4b6538
leaq 0x2334d1(%rip), %rax    # 0x39e870
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x16b3bb
movsd 0x349a5a(%rip), %xmm0   # 0x4b4e10
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x34b172(%rip)   # 0x4b6538
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x233495(%rip), %rcx    # 0x39e86c
cmpl (%rcx), %eax
jge 0x16b410
movsd -0x8(%rbp), %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x349e85(%rip), %rax    # 0x4b5270
movsd %xmm0, (%rax,%rcx,8)
movsd -0x8(%rbp), %xmm0
addsd 0x34b13b(%rip), %xmm0   # 0x4b6538
movsd %xmm0, 0x34b133(%rip)   # 0x4b6538
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16b3cd
leaq 0x233455(%rip), %rax    # 0x39e86c
movl (%rax), %ecx
leaq 0x233450(%rip), %rax    # 0x39e870
movl %ecx, (%rax)
leaq 0x23344b(%rip), %rax    # 0x39e874
movl $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: enable_osc_control()
void enable_osc_control()
{
   osc_discipline = 0;
   set_discipline_mode(SET_DIS_MODE_DISABLE);

   if(rcvr_type == X72_RCVR) {
      set_x72_dds(last_x72_dds);
      osc_pid_initial_voltage = (DATA_SIZE) last_x72_dds;
   }
   else {
      set_dac_voltage(dac_voltage, 5);
      osc_pid_initial_voltage = dac_voltage;
   }

   osc_control_on = 1;
   osc_rampup = 1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x200849(%rip), %rax    # 0x36c674
movb $0x0, (%rax)
movl $0x4, %edi
callq 0x95180
leaq 0x10bc71(%rip), %rax    # 0x277ab0
cmpq $0x2000000, (%rax)      # imm = 0x2000000
jne 0x16be70
leaq 0x10e271(%rip), %rax    # 0x27a0c0
movsd (%rax), %xmm0
callq 0x9a4f0
leaq 0x10e261(%rip), %rax    # 0x27a0c0
movsd (%rax), %xmm0
leaq 0x2004d6(%rip), %rax    # 0x36c340
movsd %xmm0, (%rax)
jmp 0x16be9b
leaq 0x1ffd69(%rip), %rax    # 0x36bbe0
movsd (%rax), %xmm0
movl $0x5, %edi
callq 0x94640
leaq 0x1ffd54(%rip), %rax    # 0x36bbe0
movsd (%rax), %xmm0
leaq 0x2004a9(%rip), %rax    # 0x36c340
movsd %xmm0, (%rax)
leaq 0x232a16(%rip), %rax    # 0x39e8b8
movb $0x1, (%rax)
leaq 0x232a14(%rip), %rax    # 0x39e8c0
movsd 0x31b4(%rip), %xmm0     # 0x16f068
movsd %xmm0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: control_osc()
void control_osc()
{
double true_pps;

   // calculate integral of osc signal
   if(trick_scale) {
      if(trick_tick) --trick_tick;
      else {
         true_pps = (pps_offset + trick_value);
         trick_value = (true_pps * trick_scale);

         if(trick_value > MAX_TRICK) trick_value = MAX_TRICK;
         else if(trick_value <= (-MAX_TRICK)) trick_value = (-MAX_TRICK);

         set_pps(user_pps_enable, pps_polarity,  trick_value*1.0E-9, pps1_delay, 300.0, 0);
         request_pps_info();
         sprintf(plot_title,  "Cable trick:  scale=%f  ofs=%f", trick_scale, trick_value);
         title_type = OTHER;
         trick_tick = 5;
      }
   }

   if(osc_control_on) {  // we are controlling the oscillator disciplining
      osc_pid_filter();
   }

   if(dac_dac) {         // we are doing a osc param autotune
      calc_osc_gain();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x232a29(%rip), %rax    # 0x39e8f8
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x16bee3
jp 0x16bee3
jmp 0x16c01c
cmpl $0x0, 0x34a656(%rip)    # 0x4b6540
je 0x16bf00
movl 0x34a64e(%rip), %eax    # 0x4b6540
addl $-0x1, %eax
movl %eax, 0x34a645(%rip)    # 0x4b6540
jmp 0x16c01a
leaq 0x1ffa91(%rip), %rax    # 0x36b998
movsd (%rax), %xmm0
leaq 0x2329f6(%rip), %rax    # 0x39e908
addsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
leaq 0x2329d1(%rip), %rax    # 0x39e8f8
mulsd (%rax), %xmm0
leaq 0x2329d6(%rip), %rax    # 0x39e908
movsd %xmm0, (%rax)
leaq 0x2329cb(%rip), %rax    # 0x39e908
movsd (%rax), %xmm0
movsd 0x30e7(%rip), %xmm1     # 0x16f030
ucomisd %xmm1, %xmm0
jbe 0x16bf64
leaq 0x2329b2(%rip), %rax    # 0x39e908
movsd 0x30d2(%rip), %xmm0     # 0x16f030
movsd %xmm0, (%rax)
jmp 0x16bf8e
movsd 0x3194(%rip), %xmm0     # 0x16f100
leaq 0x232995(%rip), %rax    # 0x39e908
ucomisd (%rax), %xmm0
jb 0x16bf8c
leaq 0x232988(%rip), %rax    # 0x39e908
movsd 0x3178(%rip), %xmm0     # 0x16f100
movsd %xmm0, (%rax)
jmp 0x16bf8e
leaq 0x200f6c(%rip), %rax    # 0x36cf01
movb (%rax), %cl
leaq 0x200f5a(%rip), %rax    # 0x36cef8
movl (%rax), %eax
movsd 0x31c0(%rip), %xmm0     # 0x16f168
leaq 0x232959(%rip), %rdx    # 0x39e908
mulsd (%rdx), %xmm0
leaq 0x200ffe(%rip), %rdx    # 0x36cfb8
movsd (%rdx), %xmm1
movss 0x335a(%rip), %xmm2     # 0x16f320
xorl %edx, %edx
movzbl %cl, %edi
movzbl %al, %esi
callq 0x91b20
callq 0x91720
leaq 0x232919(%rip), %rax    # 0x39e8f8
movsd (%rax), %xmm0
leaq 0x23291e(%rip), %rax    # 0x39e908
movsd (%rax), %xmm1
leaq 0x231a3b(%rip), %rdi    # 0x39da30
leaq 0x2cca2(%rip), %rsi     # 0x198c9e
movb $0x2, %al
callq 0x9060
leaq 0x2324a2(%rip), %rax    # 0x39e4ac
movl $0x3, (%rax)
movl $0x5, 0x34a526(%rip)    # 0x4b6540
jmp 0x16c01c
leaq 0x232895(%rip), %rax    # 0x39e8b8
cmpb $0x0, (%rax)
je 0x16c02d
callq 0x16b660
leaq 0x22e9c8(%rip), %rax    # 0x39a9fc
cmpl $0x0, (%rax)
je 0x16c03e
callq 0x168b80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: logg2(long)
int logg2(long x)
{
    unsigned long mask,i;

    if(x == 0) return(-1L);     /* zero is an error, return -1 */
    x--;                        /* get the max index, x-1 */

    for(mask=1,i=0; ; mask*=2,i++) {
        if(x == 0) return(i);   /* return logg2 if all zero */
        x = x & (~mask);        /* AND off a bit */
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16c7f8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16c850
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16c824
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x16c850
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16c814
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: calc_fft(int)
long calc_fft(int id)
{
long length, m;
long points;

   fft_id = id;
   set_fft_scale();

   if(fft_type == HIST_TYPE) {  // do histogram instead of an FFT
      if(id == FFT) {
//      edit_error("Cannot calculate the histogram of the histogram plot!");
//      return 0;
id = pre_fft_plot;
      }
      points = calc_plot_hist(id);
   }
   else {  // do FFT instead of histogram
      if(id == FFT) {
        edit_error("Cannot calculate the FFT of the FFT plot!");
        return 0;
      }

      length = max_fft_len;
      if(length < 2) {  /* Check for power of 2 input size */
        edit_error("FFT size must be a power of 2 greater than 1");
        return 0;
      }

      m = logg2(length);
      if((1<<m) != length) {  /* Check for power of 2 input size */
        edit_error("FFT size must be a power of 2.");
        return 0;
      }

      fps = ((1.0F/view_interval)/2.0F) / (float) (length/2);
      points = process_signal(length, id);
   }

   // set scale factors and enable the FFT plot
   if(show_live_fft == 0) {
      plot[FFT].show_stat = 1;
      if(plot[FFT].show_plot == 0) toggle_plot(FFT);
   }

   return points;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
leaq 0x10cbd7(%rip), %rax    # 0x27a65e
movb %cl, (%rax)
callq 0x16d560
leaq 0x10cbc8(%rip), %rax    # 0x27a65d
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x16dac0
cmpl $0xe, -0xc(%rbp)
jne 0x16daaf
leaq 0x23149a(%rip), %rax    # 0x39ef44
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x16dbf0
movq %rax, -0x28(%rbp)
jmp 0x16dba0
cmpl $0xe, -0xc(%rbp)
jne 0x16dadf
leaq 0x2b296(%rip), %rdi     # 0x198d63
callq 0x30d60
movq $0x0, -0x8(%rbp)
jmp 0x16dbe4
leaq 0x231472(%rip), %rax    # 0x39ef58
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jge 0x16db0d
leaq 0x2b292(%rip), %rdi     # 0x198d8d
callq 0x30d60
movq $0x0, -0x8(%rbp)
jmp 0x16dbe4
movq -0x18(%rbp), %rdi
callq 0x16c7e0
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
cmpq -0x18(%rbp), %rax
je 0x16db4a
leaq 0x2b282(%rip), %rdi     # 0x198dba
callq 0x30d60
movq $0x0, -0x8(%rbp)
jmp 0x16dbe4
leaq 0x10ca2f(%rip), %rax    # 0x27a580
cvtsi2ssq (%rax), %xmm1
movss 0x3dde(%rip), %xmm0     # 0x17193c
divss %xmm1, %xmm0
movss 0x15802(%rip), %xmm1    # 0x18336c
divss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
leaq 0x2313e4(%rip), %rax    # 0x39ef70
movss %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x16c860
movq %rax, -0x28(%rbp)
leaq 0x10ca63(%rip), %rax    # 0x27a60a
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x16dbdc
leaq 0x4f16a(%rip), %rax     # 0x1bcd20
movl $0x1, 0xd84(%rax)
leaq 0x4f159(%rip), %rax     # 0x1bcd20
cmpl $0x0, 0xcc8(%rax)
jne 0x16dbda
movl $0xe, %edi
callq 0x47bf0
jmp 0x16dbdc
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: dump_hist_plot()
void dump_hist_plot()
{
int i;
DATA_SIZE val;

   // dump the plot histogram data to the debug_file

   if(debug_file == 0) return;
   if(plot[FFT].show_plot == 0) return;
   if(fft_type != HIST_TYPE) return;

   if(show_live_fft) {
      fprintf(debug_file, "\nLive %s plot histogram:\n", plot[fft_id].plot_id);
   }
   else {
      fprintf(debug_file, "\nSingle %s plot histogram:\n", plot[fft_id].plot_id);
   }

   for(i=0; i<hist_size; i++) {
      if(plot_hist[i] == 0) continue;  // empty bin
      val = hist_minv + (hist_bin_width*((DATA_SIZE) i));
      fprintf(debug_file, "bin:%d  val:%.9f  count:%ld\n", i, val, plot_hist[i]);
   }

   fprintf(debug_file, "\n");
   fflush(debug_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x12f191(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
jne 0x16e3ea
jmp 0x16e548
leaq 0x4e92f(%rip), %rax     # 0x1bcd20
cmpl $0x0, 0xcc8(%rax)
jne 0x16e3ff
jmp 0x16e548
leaq 0x10c257(%rip), %rax    # 0x27a65d
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x16e413
jmp 0x16e548
leaq 0x10c1f0(%rip), %rax    # 0x27a60a
cmpb $0x0, (%rax)
je 0x16e459
leaq 0x12f14a(%rip), %rax    # 0x29d570
movq (%rax), %rdi
leaq 0x10c22e(%rip), %rax    # 0x27a65e
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x4e8e4(%rip), %rax     # 0x1bcd20
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x2a989(%rip), %rsi     # 0x198dd9
movb $0x0, %al
callq 0x9550
jmp 0x16e491
leaq 0x12f110(%rip), %rax    # 0x29d570
movq (%rax), %rdi
leaq 0x10c1f4(%rip), %rax    # 0x27a65e
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x4e8aa(%rip), %rax     # 0x1bcd20
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x2a969(%rip), %rsi     # 0x198df3
movb $0x0, %al
callq 0x9550
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
leaq 0x1141cd(%rip), %rcx    # 0x282670
cmpq (%rcx), %rax
jge 0x16e521
movslq -0x4(%rbp), %rcx
leaq 0x10c1bd(%rip), %rax    # 0x27a670
cmpq $0x0, (%rax,%rcx,8)
jne 0x16e4bc
jmp 0x16e513
leaq 0x1141b5(%rip), %rax    # 0x282678
movsd (%rax), %xmm1
leaq 0x1141ba(%rip), %rax    # 0x282688
movsd (%rax), %xmm0
cvtsi2sdl -0x4(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq 0x12f085(%rip), %rax    # 0x29d570
movq (%rax), %rdi
movl -0x4(%rbp), %edx
movsd -0x10(%rbp), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x10c16f(%rip), %rax    # 0x27a670
movq (%rax,%rcx,8), %rcx
leaq 0x2a903(%rip), %rsi     # 0x198e0f
movb $0x1, %al
callq 0x9550
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x16e498
leaq 0x12f048(%rip), %rax    # 0x29d570
movq (%rax), %rdi
leaq 0x2a0f4(%rip), %rsi     # 0x198626
movb $0x0, %al
callq 0x9550
leaq 0x12f030(%rip), %rax    # 0x29d570
movq (%rax), %rdi
callq 0x9430
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: scale_hist_val(int, double)
DATA_SIZE scale_hist_val(int id, DATA_SIZE val)
{
   // convert a raw plot queue data value to it's displayed value

//!!!!!! we need to handle more cases... see label_cursor_val()
   if(tie_plot(id)) {  // it's a time interval error plot
      if(plot[id].show_freq) {  // frequency mode
         val = (DATA_SIZE) tie_to_freq(id, (double) val);
      } 
   }
   else if(id == TEMP) {
////  val /= 1000.0;
   }

   return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x19760
cmpl $0x0, %eax
je 0x16e59f
movslq -0x4(%rbp), %rcx
leaq 0x4e7a8(%rip), %rax     # 0x1bcd20
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0xd0(%rax)
je 0x16e59d
movl -0x4(%rbp), %edi
movsd -0x10(%rbp), %xmm0
callq 0xebbe0
movsd %xmm0, -0x10(%rbp)
jmp 0x16e5a9
cmpl $0x3, -0x4(%rbp)
jne 0x16e5a7
jmp 0x16e5a7
jmp 0x16e5a9
movsd -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_53.cc
// Function: main
int main(int argc, char const *argv[])
{
	int i = 0;
	double d = 3.14;
	std::string s = "Hello World!";
	Foo foo;
	Str str;
	// error: cannot bind ‘std::ostream {aka std::basic_ostream<char>}’ lvalue to ‘std::basic_ostream<char>&&’
	// return os << t;
	// print(std::cout, foo);
	print(std::cout, 1) << std::endl;
	print(std::cout, 1, 2.0f) << std::endl;
	print(std::cout, 1, 2.0f, s, str) << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movabsq $0x40091eb851eb851f, %rax # imm = 0x40091EB851EB851F
movq %rax, -0x20(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x10e0
movq -0x98(%rbp), %rdx
leaq 0xd58(%rip), %rsi       # 0x2004
leaq -0x40(%rbp), %rdi
callq 0x10a0
jmp 0x12b7
leaq -0x41(%rbp), %rdi
callq 0x1090
leaq -0x78(%rbp), %rdi
callq 0x1410
jmp 0x12cb
movl $0x1, -0x7c(%rbp)
movq 0x2cff(%rip), %rdi      # 0x3fd8
leaq -0x7c(%rbp), %rsi
callq 0x1480
movq %rax, -0xa0(%rbp)
jmp 0x12eb
movq -0xa0(%rbp), %rdi
movq 0x2ccf(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x1300
movl $0x1, -0x80(%rbp)
movl $0x40000000, -0x84(%rbp) # imm = 0x40000000
movq 0x2cc0(%rip), %rdi      # 0x3fd8
leaq -0x80(%rbp), %rsi
leaq -0x84(%rbp), %rdx
callq 0x14b0
movq %rax, -0xa8(%rbp)
jmp 0x1331
movq -0xa8(%rbp), %rdi
movq 0x2c89(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x1346
movl $0x1, -0x88(%rbp)
movl $0x40000000, -0x8c(%rbp) # imm = 0x40000000
movq 0x2c77(%rip), %rdi      # 0x3fd8
leaq -0x88(%rbp), %rsi
leaq -0x8c(%rbp), %rdx
leaq -0x40(%rbp), %rcx
leaq -0x78(%rbp), %r8
callq 0x1500
movq %rax, -0xb0(%rbp)
jmp 0x1385
movq -0xb0(%rbp), %rdi
movq 0x2c35(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x139a
movl $0x0, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1560
leaq -0x40(%rbp), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x1090
jmp 0x1402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x13f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1560
leaq -0x40(%rbp), %rdi
callq 0x1030
movq -0x50(%rbp), %rdi
callq 0x10d0
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/sci_dec.cc
// Function: main
int main() 
{
	cout << "default format: " << 100 * sqrt(2.0) << '\n'
		 << "scientific: " << scientific << 100 * sqrt(2.0) << '\n'
	     << "fixed decimal: " << fixed << 100 * sqrt(2.0) << '\n'
#ifdef HEX_MANIPS     // no workaround for this missing manipulator
		 << "hexadecimal: " << hexfloat << 100 * sqrt(2.0) << '\n'
#endif
		 << "use defaults: " << defaultfloat << 100 * sqrt(2.0) 
		 << "\n\n";
	
	cout << uppercase
	     << "scientific: " << scientific << sqrt(2.0) << '\n'
	     << "fixed decimal: " << fixed << sqrt(2.0) << '\n'
#ifdef HEX_MANIPS     // no workaround for this missing manipulator
		 << "hexadecimal: " << hexfloat << sqrt(2.0) << "\n\n"
#endif
		 << nouppercase;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dd2(%rip), %rdi      # 0x3fd8
leaq 0xe0b(%rip), %rsi       # 0x2018
callq 0x1060
movq %rax, -0x38(%rbp)
movsd 0xdea(%rip), %xmm0      # 0x2008
callq 0x1040
movq -0x38(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0xdde(%rip), %xmm0      # 0x2010
mulsd %xmm1, %xmm0
callq 0x10a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x1080
movq %rax, %rdi
leaq 0xdd7(%rip), %rsi       # 0x2029
callq 0x1060
movq %rax, %rdi
leaq 0x19f(%rip), %rsi       # 0x1400
callq 0x1030
movq %rax, -0x30(%rbp)
movsd 0xd96(%rip), %xmm0      # 0x2008
callq 0x1040
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0xd8a(%rip), %xmm0      # 0x2010
mulsd %xmm1, %xmm0
callq 0x10a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x1080
movq %rax, %rdi
leaq 0xd90(%rip), %rsi       # 0x2036
callq 0x1060
movq %rax, %rdi
leaq 0x17b(%rip), %rsi       # 0x1430
callq 0x1030
movq %rax, -0x28(%rbp)
movsd 0xd42(%rip), %xmm0      # 0x2008
callq 0x1040
movq -0x28(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0xd36(%rip), %xmm0      # 0x2010
mulsd %xmm1, %xmm0
callq 0x10a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x1080
movq %rax, %rdi
leaq 0xd4c(%rip), %rsi       # 0x2046
callq 0x1060
movq %rax, %rdi
leaq 0x157(%rip), %rsi       # 0x1460
callq 0x1070
movq %rax, -0x20(%rbp)
movsd 0xcee(%rip), %xmm0      # 0x2008
callq 0x1040
movq -0x20(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0xce2(%rip), %xmm0      # 0x2010
mulsd %xmm1, %xmm0
callq 0x10a0
movq %rax, %rdi
leaq 0xd14(%rip), %rsi       # 0x2055
callq 0x1060
movq 0x2c8b(%rip), %rdi      # 0x3fd8
leaq 0x13c(%rip), %rsi       # 0x1490
callq 0x1030
movq %rax, %rdi
leaq 0xcc6(%rip), %rsi       # 0x2029
callq 0x1060
movq %rax, %rdi
leaq 0x8e(%rip), %rsi        # 0x1400
callq 0x1030
movq %rax, -0x18(%rbp)
movsd 0xc85(%rip), %xmm0      # 0x2008
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x10a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x1080
movq %rax, %rdi
leaq 0xc8e(%rip), %rsi       # 0x2036
callq 0x1060
movq %rax, %rdi
leaq 0x79(%rip), %rsi        # 0x1430
callq 0x1030
movq %rax, -0x10(%rbp)
movsd 0xc40(%rip), %xmm0      # 0x2008
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x1080
movq %rax, %rdi
leaq 0xd3(%rip), %rsi        # 0x14c0
callq 0x1030
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/../../CH01_GettingStarted/examples/Sales_item.h
// Function: operator>>(std::istream&, Sales_item&)
std::istream&
operator>>(std::istream& in, Sales_item& s)
{
    double price;
    in >> s.bookNo >> s.units_sold >> price;
    // check that the inputs succeeded
    if (in)
        s.revenue = s.units_sold * price;
    else
        s = Sales_item();  // input failed: reset object to default state
    return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x2030
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x20d0
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2160
testb $0x1, %al
jne 0x244f
jmp 0x246b
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cvtsi2sd %rax, %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x28(%rax)
jmp 0x249a
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x20a0
leaq -0x48(%rbp), %rdi
callq 0x3a80
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3ac0
leaq -0x48(%rbp), %rdi
callq 0x3a60
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mxy161610207[P]codesim/src/MyPaser.cpp
// Function: TouchFile(char const*)
bool TouchFile(const char* filename) {
	std::ifstream ifs(filename);
	if (!ifs.is_open()) {
		fprintf(stderr, "File [%s] not exsit.\n", filename);
		exit(-1);
	}
	ifs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movl $0x8, %edx
callq 0x2430
movq -0x228(%rbp), %rdi
callq 0x23c0
movb %al, -0x21d(%rbp)
jmp 0x266f
movb -0x21d(%rbp), %al
testb $0x1, %al
jne 0x26c1
jmp 0x267b
movq 0xc956(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x79d0(%rip), %rsi      # 0xa060
movb $0x0, %al
callq 0x2360
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x20b0
jmp 0x26d1
leaq -0x210(%rbp), %rdi
callq 0x20a0
jmp 0x26cf
ud2
movq -0x218(%rbp), %rdi
callq 0x23f0
nopl (%rax)
// File: mxy161610207[P]codesim/src/MyPaser.cpp
// Function: ExecCmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int ExecCmd(string cmd, string& res) {
	if (cmd.size() == 0) {  //cmd is empty 
		return -1;
	}

	char buffer[1024] = { 0 };
	string result = "";
	FILE* pin = popen(cmd.c_str(), "r");
	if (!pin) { //popen failed 
		return -1;
	}

	res.clear();
	while (!feof(pin)) {
		if (fgets(buffer, sizeof(buffer), pin) != NULL) {
			result += buffer;
		}
	}

	res = result;
	return pclose(pin); //-1:pclose failed; else shell ret
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp            # imm = 0x490
movq %rdi, -0x470(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x21b0
cmpq $0x0, %rax
jne 0x2711
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x28a6
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2160
leaq -0x441(%rbp), %rdi
movq %rdi, -0x478(%rbp)
callq 0x2400
movq -0x478(%rbp), %rdx
leaq 0x7945(%rip), %rsi      # 0xa08a
leaq -0x440(%rbp), %rdi
callq 0x44a0
jmp 0x2753
leaq -0x441(%rbp), %rdi
callq 0x22a0
movq -0x470(%rbp), %rdi
callq 0x2100
movq %rax, %rdi
leaq 0x7901(%rip), %rsi      # 0xa076
callq 0x20d0
movq %rax, -0x480(%rbp)
jmp 0x2783
movq -0x480(%rbp), %rax
movq %rax, -0x460(%rbp)
cmpq $0x0, -0x460(%rbp)
jne 0x27f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x464(%rbp)
jmp 0x289a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x450(%rbp)
movl %eax, -0x454(%rbp)
leaq -0x441(%rbp), %rdi
callq 0x22a0
jmp 0x28b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x450(%rbp)
movl %eax, -0x454(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x2180
jmp 0x28b2
movq -0x18(%rbp), %rdi
callq 0x2330
movq -0x460(%rbp), %rdi
callq 0x23a0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x281a
jmp 0x2861
movq -0x460(%rbp), %rdx
leaq -0x420(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x23b0
movq %rax, -0x488(%rbp)
jmp 0x283b
movq -0x488(%rbp), %rax
cmpq $0x0, %rax
je 0x285f
leaq -0x440(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x2230
jmp 0x285d
jmp 0x285f
jmp 0x2800
movq -0x18(%rbp), %rdi
leaq -0x440(%rbp), %rsi
callq 0x2050
jmp 0x2873
movq -0x460(%rbp), %rdi
callq 0x2350
movl %eax, -0x48c(%rbp)
jmp 0x2887
movl -0x48c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x464(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x2180
movl -0x4(%rbp), %eax
addq $0x490, %rsp            # imm = 0x490
popq %rbp
retq
movq -0x450(%rbp), %rdi
callq 0x23f0
nop
// File: mxy161610207[P]codesim/src/MyPaser.cpp
// Function: SplitStringToVect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int SplitStringToVect(const string& srcStr, vector<string>& destVect, const string& strFlag)
{
	int pos = srcStr.find(strFlag, 0);
	int startPos = 0;
	int splitN = pos;
	string lineText(strFlag);

	while (pos > -1)
	{
		lineText = srcStr.substr(startPos, splitN);
		startPos = pos + 1;
		pos = srcStr.find(strFlag, pos + 1);
		splitN = pos - startPos;
		destVect.push_back(lineText);
	}

	lineText = srcStr.substr(startPos, srcStr.length() - startPos);
	destVect.push_back(lineText);

	return destVect.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2460
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2110
cmpl $-0x1, -0x1c(%rbp)
jle 0x29a9
movq -0x8(%rbp), %rsi
movslq -0x20(%rbp), %rdx
movslq -0x24(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x2270
jmp 0x2926
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x22f0
movq -0xa8(%rbp), %rdi
callq 0x2180
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
incl %eax
movslq %eax, %rdx
callq 0x2460
movq -0xa0(%rbp), %rsi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4550
jmp 0x298a
jmp 0x2905
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2180
jmp 0x2a4d
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x2380
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq %rax, %rcx
movslq -0x20(%rbp), %rax
subq %rax, %rcx
leaq -0x98(%rbp), %rdi
callq 0x2270
jmp 0x29ea
leaq -0x48(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x98(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rdi
callq 0x2180
movq -0xc0(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x4550
jmp 0x2a26
movq -0x10(%rbp), %rdi
callq 0x45c0
movl %eax, -0xcc(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2180
movl -0xcc(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x23f0
nopw %cs:(%rax,%rax)
// File: mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::Program::GetFuncNameFromStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int MyPaser::Program::GetFuncNameFromStr(const string& context) {
	vector<string> lines;
	lines.clear();
	SplitStringToVect(context, lines, "\n");

	for (auto &l : lines) {
		if (l.find("g     F .text") != string::npos) {
			int pos = l.find_last_of(" ");
			string funcName = l.substr(pos + 1, l.size() - pos);
			//cout << l << ":" << funcName << endl;
			//cout << funcName << endl;
			this->funcName_.push_back(funcName);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x45e0
movq -0xc0(%rbp), %rdi
callq 0x4600
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x2400
movq -0xb0(%rbp), %rdx
leaq 0x75b1(%rip), %rsi      # 0xa074
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x2ace
movq -0xb8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x28c0
jmp 0x2ae4
leaq -0x48(%rbp), %rdi
callq 0x2180
leaq -0x49(%rbp), %rdi
callq 0x22a0
leaq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x4620
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x4650
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4680
testb $0x1, %al
jne 0x2b2e
jmp 0x2c49
leaq -0x70(%rbp), %rdi
callq 0x46c0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
leaq 0x7532(%rip), %rsi      # 0xa078
xorl %eax, %eax
movl %eax, %edx
callq 0x2450
cmpq $-0x1, %rax
je 0x2c39
movq -0x80(%rbp), %rdi
leaq 0x7522(%rip), %rsi      # 0xa086
movq $-0x1, %rdx
callq 0x2220
movl %eax, -0x84(%rbp)
movq -0x80(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movl -0x84(%rbp), %eax
incl %eax
cltq
movq %rax, -0xd0(%rbp)
callq 0x21b0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq %rax, %rcx
movslq -0x84(%rbp), %rax
subq %rax, %rcx
leaq -0xa8(%rbp), %rdi
callq 0x2270
jmp 0x2bc0
movq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x4550
jmp 0x2bd5
leaq -0xa8(%rbp), %rdi
callq 0x2180
jmp 0x2c39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2c06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2180
leaq -0x49(%rbp), %rdi
callq 0x22a0
jmp 0x2c5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2c5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2180
jmp 0x2c5d
jmp 0x2c3b
leaq -0x70(%rbp), %rdi
callq 0x46e0
jmp 0x2b18
leaq -0x28(%rbp), %rdi
callq 0x4700
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4700
movq -0x58(%rbp), %rdi
callq 0x23f0
nop
// File: mxy161610207[P]codesim/src/MyPaser.cpp
// Function: SplitDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string SplitDirectory(string fulldir) {
	int pos = fulldir.find_last_of("/");
	//cout << pos << endl;
	if (pos == string::npos) {
		return fulldir;
	}
	else {
		return fulldir.substr(pos+1, fulldir.size() - pos);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x6ffe(%rip), %rsi      # 0xa08b
movq $-0x1, %rdx
callq 0x2220
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $-0x1, %rax
jne 0x30b5
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x2170
jmp 0x30e5
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x38(%rbp)
callq 0x21b0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movslq -0x14(%rbp), %rax
subq %rax, %rcx
callq 0x2270
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::Program::PrintfFuncOptoFile(char const*)
void MyPaser::Program::PrintfFuncOptoFile(const char* filename) {
	FILE* f = fopen(filename, "w");
	for (auto &name : this->funcName_) {
		fprintf(f, "[%s]:\n", name.c_str());
		for (auto &op : this->functOp_[name]) {
			fprintf(f, "%s,", op.c_str());
		}
		fprintf(f, "\n");
	}
	fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f7a(%rip), %rsi      # 0xa08d
callq 0x22d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4620
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4650
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4680
testb $0x1, %al
jne 0x3157
jmp 0x322a
leaq -0x28(%rbp), %rdi
callq 0x46c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2100
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0x6f0c(%rip), %rsi      # 0xa08f
movb $0x0, %al
callq 0x2360
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq -0x38(%rbp), %rsi
callq 0x4760
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4620
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4650
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4680
testb $0x1, %al
jne 0x31cc
jmp 0x320a
leaq -0x48(%rbp), %rdi
callq 0x46c0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2100
movq -0x70(%rbp), %rdi
movq %rax, %rdx
leaq 0x6e9e(%rip), %rsi      # 0xa096
movb $0x0, %al
callq 0x2360
leaq -0x48(%rbp), %rdi
callq 0x46e0
jmp 0x31b9
movq -0x18(%rbp), %rdi
leaq 0x6e5f(%rip), %rsi      # 0xa074
movb $0x0, %al
callq 0x2360
leaq -0x28(%rbp), %rdi
callq 0x46e0
jmp 0x3141
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::PaserCompare(char*, char*)
double MyPaser::PaserCompare(char* filename1, char* filename2) {
	MyPaser::Program A;
	MyPaser::Program B;

	if (TouchFile(filename1) && TouchFile(filename2)) {
		GetFuncList(filename1, A);
		GetFuncList(filename2, B);

		return max(Compare(A, B), Compare(B, A));
		//9return  Compare(A, B);

		//printf("%s\n", filename1);
		//string s = SplitDirectory(filename1);
		//printf("%s\n", s.c_str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4d40
leaq -0xa0(%rbp), %rdi
callq 0x4d40
jmp 0x434a
movq -0x8(%rbp), %rdi
callq 0x2630
movb %al, -0xc1(%rbp)
jmp 0x435b
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x436a
jmp 0x4488
movq -0x10(%rbp), %rdi
callq 0x2630
movb %al, -0xc2(%rbp)
jmp 0x437b
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0x438a
jmp 0x4488
movq -0x8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3f60
jmp 0x4399
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3f60
jmp 0x43ab
leaq -0x58(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x42f0
movsd %xmm0, -0xd0(%rbp)
jmp 0x43c5
movsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x42f0
movsd %xmm0, -0xd8(%rbp)
jmp 0x43ef
movsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x4d90
movq %rax, -0xe0(%rbp)
jmp 0x441b
movq -0xe0(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0xe8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x4dd0
leaq -0x58(%rbp), %rdi
callq 0x4dd0
movsd -0xe8(%rbp), %xmm0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x448a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x4dd0
jmp 0x448a
ud2
leaq -0x58(%rbp), %rdi
callq 0x4dd0
movq -0xa8(%rbp), %rdi
callq 0x23f0
nop
// File: mxy161610207[P]codesim/./include/MaximumWeightFlow.h
// Function: Graph::addedge(int, int, int, double)
void addedge(int u, int v, int cap, double cost)
	{
		edge[tol].to = v;
		edge[tol].cap = cap;
		edge[tol].cost = cost;
		edge[tol].flow = 0;
		edge[tol].next = head[u];
		head[u] = tol++;
		edge[tol].to = u;
		edge[tol].cap = 0;
		edge[tol].cost = -cost;
		edge[tol].flow = 0;
		edge[tol].next = head[v];
		head[v] = tol++;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
movl %edx, (%rcx)
movl -0x14(%rbp), %edx
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
movl %edx, 0x8(%rcx)
movsd -0x20(%rbp), %xmm0
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movsd %xmm0, 0x10(%rcx)
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl $0x0, 0xc(%rcx)
movslq -0xc(%rbp), %rcx
movl 0x24a860(%rax,%rcx,4), %edx
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
movl %edx, 0x4(%rcx)
movl 0x27411c(%rax), %edx
movl %edx, %ecx
addl $0x1, %ecx
movl %ecx, 0x27411c(%rax)
movslq -0xc(%rbp), %rcx
movl %edx, 0x24a860(%rax,%rcx,4)
movl -0xc(%rbp), %edx
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
movl %edx, (%rcx)
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl $0x0, 0x8(%rcx)
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movsd %xmm0, 0x10(%rcx)
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl $0x0, 0xc(%rcx)
movslq -0x10(%rbp), %rcx
movl 0x24a860(%rax,%rcx,4), %edx
movslq 0x27411c(%rax), %rcx
imulq $0x18, %rcx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
movl %edx, 0x4(%rcx)
movl 0x27411c(%rax), %edx
movl %edx, %ecx
addl $0x1, %ecx
movl %ecx, 0x27411c(%rax)
movslq -0x10(%rbp), %rcx
movl %edx, 0x24a860(%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: mxy161610207[P]codesim/./include/MaximumWeightFlow.h
// Function: Graph::minCostMaxflow(int, int, double&)
int minCostMaxflow(int s, int t, double& cost)
	{
		int flow = 0;
		cost = 0;
		while (spfa(s, t))
		{
			int Min = INF;
			for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to])
			{
				if (Min > edge[i].cap - edge[i].flow)
					Min = edge[i].cap - edge[i].flow;
			}
			for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to])
			{
				edge[i].flow += Min;
				edge[i ^ 1].flow -= Min;
				cost += edge[i].cost * Min;
			}
			flow += Min;
			//cout << "|" << cost << endl;
		}
		return flow;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4eb0
testb $0x1, %al
jne 0x4be8
jmp 0x4d34
movq -0x30(%rbp), %rax
movl $0x3f3f3f3f, -0x20(%rbp) # imm = 0x3F3F3F3F
movslq -0x10(%rbp), %rcx
movl 0x2544c8(%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x4c7f
movq -0x30(%rbp), %rdx
movl -0x20(%rbp), %eax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rsi
movq %rdx, %rcx
addq %rsi, %rcx
movl 0x8(%rcx), %ecx
movslq -0x24(%rbp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rdx
subl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jle 0x4c57
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
imulq $0x18, %rax, %rdx
movq %rcx, %rax
addq %rdx, %rax
movl 0x8(%rax), %eax
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x20(%rbp)
jmp 0x4c59
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
xorl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x2544c8(%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
jmp 0x4c01
movq -0x30(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x2544c8(%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
je 0x4d26
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %edx
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
addl 0xc(%rcx), %edx
movl %edx, 0xc(%rcx)
movl -0x20(%rbp), %esi
movl -0x28(%rbp), %ecx
xorl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl 0xc(%rcx), %edx
subl %esi, %edx
movl %edx, 0xc(%rcx)
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm2
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %ecx
xorl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x2544c8(%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0x4c91
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x4bd0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)