LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
leaq 0x23917c(%rip), %rbx    # 0x33fdc1
cmpb $0x0, (%rbx)
je 0x106cac
callq 0x106adf
leaq 0x23917a(%rip), %rax    # 0x33fdd0
movl (%rax), %edi
testl %edi, %edi
je 0x106c76
leaq 0x239171(%rip), %rax    # 0x33fdd4
movzbl (%rax), %esi
andl $0xf, %esi
orl $0x60, %esi
movb %sil, (%rax)
callq 0xaea5
jmp 0x106c9d
leaq 0x20764f(%rip), %rax    # 0x30e2cc
movl (%rax), %edi
imulq $0x2260, %rdi, %rax     # imm = 0x2260
leaq 0x207653(%rip), %rcx    # 0x30e2e0
cmpl $0x0, (%rcx,%rax)
jle 0x106c9d
movl $0x1, %esi
callq 0xaef7
leaq 0x2f35a(%rip), %rdi     # 0x135ffe
callq 0x5f585
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
leaq 0x2349f3(%rip), %rax    # 0x33b81c
cmpl $0x0, (%rax)
je 0x106e2f
retq
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x238862(%rip), %rax    # 0x33f6a0
movsd (%rax), %xmm0
movsd 0x34ea0e(%rip), %xmm1   # 0x455858
leaq 0x238857(%rip), %rax    # 0x33f6a8
movsd (%rax), %xmm2
movsd 0x34ea03(%rip), %xmm3   # 0x455860
leaq 0x23884c(%rip), %rax    # 0x33f6b0
movsd (%rax), %xmm4
movsd 0x34e9f8(%rip), %xmm5   # 0x455868
leaq 0x238841(%rip), %rax    # 0x33f6b8
movsd (%rax), %xmm6
movsd 0x34e9ed(%rip), %xmm7   # 0x455870
leaq 0x238836(%rip), %rax    # 0x33f6c0
movsd (%rax), %xmm8
movsd 0x34e9e8(%rip), %xmm9   # 0x455880
movsd 0x34e9e7(%rip), %xmm10  # 0x455888
movsd 0x34e9e6(%rip), %xmm11  # 0x455890
leaq 0x2387db(%rip), %rax    # 0x33f68c
movl (%rax), %eax
movl %eax, 0x20(%rsp)
movsd %xmm11, 0x18(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x8(%rsp)
movsd %xmm8, (%rsp)
leaq 0x237977(%rip), %rdi    # 0x33e850
leaq 0x2f124(%rip), %rsi     # 0x136004
movl $0x1a, %edx
movl $0x1a, %ecx
movl $0x1a, %r8d
movl $0x1a, %r9d
movb $0x8, %al
callq 0x9060
leaq 0x2383c8(%rip), %rax    # 0x33f2cc
movl $0x3, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
leaq 0x2387bb(%rip), %rbx    # 0x33f6d8
cmpb $0x0, (%rbx)
je 0x106f49
leaq 0x20656b(%rip), %rax    # 0x30d494
movb $0x1, (%rax)
leaq 0x11199d(%rip), %rax    # 0x2188d0
cmpq $0x2000000, (%rax)      # imm = 0x2000000
je 0x106f46
movl $0x5, %edi
callq 0x6d604
movb $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x34e8ce(%rip)    # 0x455820
movq %rax, 0x34e8cf(%rip)    # 0x455828
movq %rax, 0x34e8d0(%rip)    # 0x455830
movq %rax, 0x34e8d1(%rip)    # 0x455838
movq %rax, 0x34e8d2(%rip)    # 0x455840
movq %rax, 0x34e8d3(%rip)    # 0x455848
movq %rax, 0x34e8d4(%rip)    # 0x455850
leaq 0x23870d(%rip), %rax    # 0x33f690
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x106f94
// File: /workspace/github_cpp_makefile_star2_O3/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:
leaq 0x2386f5(%rip), %rax    # 0x33f690
movl (%rax), %ecx
testl %ecx, %ecx
je 0x106fb3
movsd 0x34ff9f(%rip), %xmm0   # 0x456f48
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
jmp 0x106fbb
movsd 0x34e865(%rip), %xmm0   # 0x455820
movq $0x0, 0x34ff82(%rip) # 0x456f48
leaq 0x2386bf(%rip), %rcx    # 0x33f68c
movslq (%rcx), %rcx
testq %rcx, %rcx
jle 0x107003
movq %rcx, %rdx
shlq $0x3, %rdx
xorpd %xmm1, %xmm1
xorl %esi, %esi
leaq 0x34ec97(%rip), %rdi    # 0x455c80
movsd %xmm0, (%rsi,%rdi)
addsd %xmm0, %xmm1
addq $0x8, %rsi
cmpq %rsi, %rdx
jne 0x106fe9
movsd %xmm1, 0x34ff45(%rip)   # 0x456f48
pushq %rbp
movq %rsp, %rbp
movl %ecx, (%rax)
leaq 0x238684(%rip), %rax    # 0x33f694
movl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
leaq 0x205ddb(%rip), %rax    # 0x30d494
movb $0x0, (%rax)
movl $0x4, %edi
callq 0x6d604
leaq 0x111203(%rip), %rax    # 0x2188d0
cmpq $0x2000000, (%rax)      # imm = 0x2000000
jne 0x1076e8
leaq 0x113803(%rip), %rbx    # 0x21aee0
movsd (%rbx), %xmm0
callq 0x70fb0
jmp 0x1076fd
leaq 0x205311(%rip), %rbx    # 0x30ca00
movsd (%rbx), %xmm0
movl $0x5, %edi
callq 0x6ce5e
movsd (%rbx), %xmm0
leaq 0x205a58(%rip), %rax    # 0x30d160
movsd %xmm0, (%rax)
leaq 0x237fc5(%rip), %rax    # 0x33f6d8
movb $0x1, (%rax)
leaq 0x237fc3(%rip), %rax    # 0x33f6e0
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
leaq 0x237fd9(%rip), %rbx    # 0x33f718
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x107753
jnp 0x10781a
movl 0x34f7f7(%rip), %eax    # 0x456f50
testl %eax, %eax
je 0x107764
decl %eax
jmp 0x107814
leaq 0x20504d(%rip), %rax    # 0x30c7b8
movsd (%rax), %xmm1
leaq 0x237fb2(%rip), %r14    # 0x33f728
addsd (%r14), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14)
movsd 0x18ac(%rip), %xmm1     # 0x109038
ucomisd %xmm1, %xmm0
ja 0x1077a0
movsd 0x1946(%rip), %xmm1     # 0x1090e0
ucomisd %xmm0, %xmm1
jb 0x1077a9
movsd %xmm1, (%r14)
movapd %xmm1, %xmm0
leaq 0x206571(%rip), %rax    # 0x30dd21
movzbl (%rax), %edi
leaq 0x20655e(%rip), %rax    # 0x30dd18
movzbl (%rax), %esi
mulsd 0x1983(%rip), %xmm0     # 0x109148
leaq 0x20660c(%rip), %rax    # 0x30ddd8
movsd (%rax), %xmm1
movss 0x25110(%rip), %xmm2    # 0x12c8e8
xorl %edx, %edx
callq 0x6add8
callq 0x6ab01
movsd (%rbx), %xmm0
movsd (%r14), %xmm1
leaq 0x23705c(%rip), %rdi    # 0x33e850
leaq 0x2e92a(%rip), %rsi     # 0x136125
movb $0x2, %al
callq 0x9060
leaq 0x237ac3(%rip), %rax    # 0x33f2cc
movl $0x3, (%rax)
movl $0x5, %eax
movl %eax, 0x34f736(%rip)    # 0x456f50
leaq 0x237eb7(%rip), %rax    # 0x33f6d8
cmpb $0x0, (%rax)
je 0x10782b
callq 0x1071bc
leaq 0x233fea(%rip), %rax    # 0x33b81c
cmpl $0x0, (%rax)
je 0x107840
popq %rbx
popq %r14
popq %rbp
jmp 0x105337
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rdi, %rdi
je 0x107d11
decq %rdi
je 0x107d18
movl $0x1, %ecx
xorl %eax, %eax
movq %rcx, %rdx
notq %rdx
addq %rcx, %rcx
incl %eax
andq %rdx, %rdi
jne 0x107cff
jmp 0x107d1a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x107d1a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathmsc.cpp
// Function: set_fft_scale()
void set_fft_scale()
{
   // configure FFT/histogram plot

   if(fft_type == HIST_TYPE) {     // doing histogram instead of FFT
      plot[FFT].plot_id = "HIST";
      if(fft_db) plot[FFT].units = "dB";
      else       plot[FFT].units = "cnt";

      plot[FFT].user_scale = 0;
      plot[FFT].scale_factor = 1.0F;
      plot[FFT].plot_center = 0.0F;
      plot[FFT].float_center = 1;

      fft_scale = 1;
   }
   else if(fft_db) {
      plot[FFT].plot_id = "FFT";          // assume we are doing an FFT
      plot[FFT].units = "dB";

      plot[FFT].user_scale = 0;
      plot[FFT].scale_factor = 1.0F;
      plot[FFT].plot_center = 0.0F;
      plot[FFT].float_center = 1;
   }
   else {
      plot[FFT].plot_id = "FFT";          // assume we are doing an FFT
      plot[FFT].units = "x ";

      plot[FFT].user_scale = 1;
      plot[FFT].scale_factor = 1.0F / ((float) PLOT_HEIGHT/(float)(VERT_MAJOR*2));
      plot[FFT].plot_center = 0.0F;
      plot[FFT].float_center = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x112f7d(%rip), %rax    # 0x21b47d
cmpb $0x1, (%rax)
jne 0x108580
leaq 0x2dc72(%rip), %rax     # 0x13617e
leaq 0x5581d(%rip), %rcx     # 0x15dd30
movq %rax, 0xcb0(%rcx)
leaq 0x237873(%rip), %rax    # 0x33fd94
cmpb $0x0, (%rax)
leaq 0x2dc58(%rip), %rax     # 0x136183
leaq 0x1359a(%rip), %rdx     # 0x11bacc
cmoveq %rax, %rdx
movq %rdx, 0xcb8(%rcx)
movl $0x0, 0xce0(%rcx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0xce8(%rcx)
movq $0x0, 0xcd8(%rcx)
movl $0x1, 0xccc(%rcx)
leaq 0x237814(%rip), %rax    # 0x33fd88
movq $0x1, (%rax)
jmp 0x108647
leaq 0x23780d(%rip), %rax    # 0x33fd94
cmpb $0x0, (%rax)
leaq 0x1099(%rip), %rcx      # 0x10962a
leaq 0x55798(%rip), %rax     # 0x15dd30
movq %rcx, 0xcb0(%rax)
je 0x1085e1
leaq 0x13524(%rip), %rcx     # 0x11bacc
movq %rcx, 0xcb8(%rax)
movl $0x0, 0xce0(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0xce8(%rax)
movq $0x0, 0xcd8(%rax)
movl $0x1, 0xccc(%rax)
jmp 0x108647
leaq 0x1102a0(%rip), %rcx    # 0x218888
cvtsi2ssl (%rcx), %xmm0
leaq 0x1a4b5(%rip), %rcx     # 0x122aa8
movq %rcx, 0xcb8(%rax)
leaq 0x11026b(%rip), %rcx    # 0x21886c
movl (%rcx), %ecx
addl %ecx, %ecx
cvtsi2ss %ecx, %xmm1
movl $0x1, 0xce0(%rax)
divss %xmm1, %xmm0
movss 0x4a4d(%rip), %xmm1     # 0x10d06c
divss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0xce8(%rax)
movq $0x0, 0xcd8(%rax)
movl $0x0, 0xccc(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x112c50(%rip), %rax    # 0x21b47e
movb %bl, (%rax)
callq 0x1084f5
leaq 0x112c41(%rip), %rax    # 0x21b47d
cmpb $0x1, (%rax)
jne 0x108896
cmpl $0xe, %ebx
jne 0x10884f
leaq 0x237517(%rip), %rax    # 0x33fd64
movl (%rax), %ebx
movl %ebx, %edi
callq 0x10894a
movq %rax, %rbx
leaq 0x112bca(%rip), %rax    # 0x21b42a
cmpb $0x0, (%rax)
jne 0x108940
leaq 0x554c0(%rip), %rax     # 0x15dd30
movl $0x1, 0xd84(%rax)
cmpl $0x0, 0xcc8(%rax)
jne 0x108940
movl $0xe, %edi
callq 0x32f37
jmp 0x108940
cmpl $0xe, %ebx
jne 0x1088a7
leaq 0x2d948(%rip), %rdi     # 0x1361ea
jmp 0x108939
leaq 0x2374ca(%rip), %rax    # 0x33fd78
movq (%rax), %rdi
cmpq $0x1, %rdi
jg 0x1088c0
leaq 0x2d956(%rip), %rdi     # 0x136214
jmp 0x108939
leaq -0x1(%rdi), %rax
movl $0x1, %edx
xorl %ecx, %ecx
movq %rdx, %rsi
notq %rsi
addq %rdx, %rdx
incl %ecx
andq %rsi, %rax
jne 0x1088cb
movl $0x1, %eax
shll %cl, %eax
cltq
cmpq %rax, %rdi
jne 0x108932
leaq 0x112ab0(%rip), %rax    # 0x21b3a0
cvtsi2ssq (%rax), %xmm0
movss 0x476f(%rip), %xmm1     # 0x10d06c
divss %xmm0, %xmm1
mulss 0x476f(%rip), %xmm1     # 0x10d078
movq %rdi, %rax
shrq %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss %xmm0, %xmm1
leaq 0x23746e(%rip), %rax    # 0x33fd90
movss %xmm1, (%rax)
movl %ebx, %esi
callq 0x107d1c
jmp 0x108856
leaq 0x2d908(%rip), %rdi     # 0x136241
callq 0x23027
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
leaq 0x1355e8(%rip), %rax    # 0x23e390
movq (%rax), %rdi
testq %rdi, %rdi
je 0x108eb9
leaq 0x54f75(%rip), %rax     # 0x15dd30
cmpl $0x0, 0xcc8(%rax)
je 0x108eb9
leaq 0x1126ae(%rip), %rcx    # 0x21b47d
cmpb $0x1, (%rcx)
jne 0x108eb9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x11263d(%rip), %rcx    # 0x21b42a
leaq 0x11268a(%rip), %rdx    # 0x21b47e
movzbl (%rdx), %edx
imulq $0xe8, %rdx, %rdx
cmpb $0x0, (%rcx)
movq (%rax,%rdx), %rdx
leaq 0x2d46e(%rip), %rax     # 0x13627a
leaq 0x2d44d(%rip), %rsi     # 0x136260
cmoveq %rax, %rsi
xorl %eax, %eax
callq 0x9560
leaq 0x11a66b(%rip), %rax    # 0x223490
movq (%rax), %rax
testq %rax, %rax
jle 0x108e8f
xorl %ebx, %ebx
leaq 0x11265a(%rip), %r13    # 0x21b490
leaq 0x11a65b(%rip), %r15    # 0x223498
leaq 0x11a664(%rip), %r12    # 0x2234a8
leaq 0x2d44b(%rip), %r14     # 0x136296
movq (%r13,%rbx,8), %rcx
testq %rcx, %rcx
je 0x108e87
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd (%r12), %xmm0
addsd (%r15), %xmm0
leaq 0x135522(%rip), %rax    # 0x23e390
movq (%rax), %rdi
movq %r14, %rsi
movl %ebx, %edx
movb $0x1, %al
callq 0x9560
leaq 0x11a60c(%rip), %rax    # 0x223490
movq (%rax), %rax
incq %rbx
cmpq %rbx, %rax
jg 0x108e4b
leaq 0x1354fa(%rip), %rbx    # 0x23e390
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x9480
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9420
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movsd %xmm0, -0x10(%rbp)
movl %edi, %ebx
callq 0x13c3e
testl %eax, %eax
je 0x108efd
movslq %ebx, %rax
imulq $0xe8, %rax, %rax
leaq 0x54e4f(%rip), %rcx     # 0x15dd30
cmpl $0x0, 0xd0(%rcx,%rax)
je 0x108efd
movl %ebx, %edi
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xadb42
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2140
leaq 0x20(%r14), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2080
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x247f
leaq -0x50(%rbp), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movl $0x0, 0x10(%r13)
leaq -0x60(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2130
movupd 0x20(%r12), %xmm0
movupd %xmm0, (%r15)
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x2493
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2110
jmp 0x2493
movl 0x20(%r14), %eax
cvtsi2sd %rax, %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x28(%r14)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x22f0
leaq 0x80(%rsp), %rdi
callq 0x2090
testb %al, %al
je 0x2514
leaq 0x8(%rsp), %rdi
callq 0x2080
movq 0x4abd(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x1b2b(%rip), %rsi      # 0x4050
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2250
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
cmpq $0x0, 0x8(%rdi)
je 0x2617
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x2120
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1aea(%rip), %rdx      # 0x407a
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x372e
movq (%r14), %rdi
leaq 0x1ac1(%rip), %rsi      # 0x4066
callq 0x20c0
testq %rax, %rax
je 0x261e
movq %rax, %r14
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x2290
testl %eax, %eax
jne 0x2600
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x22a0
testq %rax, %rax
je 0x25f4
movq %r12, %rdi
movq %r15, %rsi
callq 0x2300
movq %r14, %rdi
callq 0x2290
testl %eax, %eax
je 0x25d4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
movl %eax, %ebx
jmp 0x2623
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x2639
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2639
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movl %ebx, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x264e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2667
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1847(%rip), %rsi      # 0x4064
leaq 0x1841(%rip), %rdx      # 0x4065
movq %rsp, %rdi
callq 0x372e
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x266f
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2857
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rbp
cmpq %rbp, %r14
je 0x28f3
leaq 0x17f7(%rip), %r15      # 0x4068
leaq 0x17fe(%rip), %r12      # 0x4076
movq %rsp, %r13
movl $0xd, %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22c0
cmpq $-0x1, %rax
je 0x28ea
movl $0x1, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x2320
leal 0x1(%rax), %ecx
movslq %ecx, %rdx
movq 0x8(%r14), %rcx
cltq
subq %rax, %rcx
movq %r13, %rdi
movq %r14, %rsi
callq 0x21d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3432
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x28ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
addq $0x20, %r14
cmpq %rbp, %r14
jne 0x287b
leaq 0x20(%rsp), %rdi
callq 0x3470
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2917
jmp 0x2912
movq %rax, %rbx
jmp 0x2935
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2935
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
leaq 0x20(%rsp), %rdi
callq 0x3470
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1477(%rip), %rsi      # 0x407b
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x2320
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
cmpq %rcx, %rax
jne 0x2c4a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x2c76
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x2c7c
movq %rax, %rsi
sarq $0x20, %rsi
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rax, %rdx
sarq $0x20, %rdx
movq 0x8(%r14), %rcx
subq %rsi, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
jmp 0x2c94
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x13c5(%rip), %rsi      # 0x407d
movq %rax, %rdi
callq 0x21f0
movq %rax, %r14
movq (%rbx), %r15
movq 0x8(%rbx), %rax
movq %rax, (%rsp)
cmpq %rax, %r15
je 0x2d37
addq $0x18, %rbx
leaq 0x13a8(%rip), %r13      # 0x4086
movq (%r15), %rdx
movq %r14, %rdi
leaq 0x1394(%rip), %rsi      # 0x407f
xorl %eax, %eax
callq 0x2250
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34ce
movq (%rax), %r12
movq 0x8(%rax), %rbp
cmpq %rbp, %r12
je 0x2d20
movq (%r12), %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x2250
addq $0x20, %r12
jmp 0x2d04
movl $0xa, %edi
movq %r14, %rsi
callq 0x2220
addq $0x20, %r15
cmpq (%rsp), %r15
jne 0x2cde
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::Compare(MyPaser::Program&, MyPaser::Program&)
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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x68(%rsp), %rbx
movaps %xmm0, -0x18(%rbx)
xorl %r12d, %r12d
movq %r12, -0x8(%rbx)
leaq 0x70(%rsp), %rax
movl %r12d, (%rax)
movq %r12, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rbx, %rdi
callq 0x3556
leaq 0x18(%rsp), %r15
movq %r12, -0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%r15)
leaq 0x20(%rsp), %rax
movl %r12d, (%rax)
movq %r12, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %r15, %rdi
callq 0x3556
movq %r14, %rdi
callq 0x24dc
movq %rax, %r14
movq %r15, %rdi
callq 0x35f4
movq %rsp, %rdi
callq 0x3470
movq %rbx, %rdi
callq 0x35f4
leaq 0x50(%rsp), %rdi
callq 0x3470
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhartmann[P]orangepi-i2s-steppers/cnt.cpp
// Function: main
int main() {
	uint32_t buff[1024];
	while (true) {
		for (uint32_t i=0; i<1024; ++i) {
			buff[i] = step();
		}
		write(STDOUT_FILENO, buff, sizeof(buff));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
xorl %r14d, %r14d
leaq -0x1010(%rbp), %rbx
callq 0x113c
movl %eax, -0x1010(%rbp,%r14,4)
incq %r14
cmpq $0x400, %r14            # imm = 0x400
jne 0x12e1
movl $0x1000, %edx           # imm = 0x1000
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1030
xorl %r14d, %r14d
jmp 0x12e1
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhartmann[P]orangepi-i2s-steppers/./throttle.h
// Function: Throttle::step()
bool step() {
        if (paused) {
            // On pause, decelerate gracefully to zero.
            if (r) r--;
        } else {
            // If before brake point
            if (n<n1) {
                // Then accelerate to max-speed
                if (r < rd) r++;
            } else {
                // Otherwise decelerate to end-speed
                if (r > r1) r--;

                // On resume, accelerate to end-speed
                if (r < r1) r++;
            }
        }
        acc += r;
        if (acc > 0) {
            acc -= rd;
            if (n < N) n++;
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x20(%rdi)
jne 0x1327
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x135e
decl %eax
jmp 0x1359
movl (%rdi), %ecx
movl 0x18(%rdi), %eax
cmpl 0x4(%rdi), %ecx
jae 0x133a
cmpl 0xc(%rdi), %eax
jae 0x1360
incl %eax
jmp 0x1359
movl 0x14(%rdi), %ecx
xorl %edx, %edx
cmpl %ecx, %eax
seta %dl
subl %edx, %eax
xorl %esi, %esi
cmpl %ecx, %eax
setb %sil
addl %esi, %eax
orb %dl, %sil
cmpb $0x1, %sil
jne 0x1360
movl %eax, 0x18(%rdi)
jmp 0x1360
xorl %eax, %eax
addl 0x1c(%rdi), %eax
movl %eax, 0x1c(%rdi)
testl %eax, %eax
jle 0x137d
movl %eax, %ecx
subl 0xc(%rdi), %ecx
movl %ecx, 0x1c(%rdi)
movl (%rdi), %ecx
cmpl 0x8(%rdi), %ecx
jae 0x137d
incl %ecx
movl %ecx, (%rdi)
testl %eax, %eax
setg %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/background_grid.cpp
// Function: load_grid()
void load_grid()
{
	int iy,ix;

	ifstream infile;
	infile.open(GRID_FILE);

	for(ix=1; ix < NPOINT+1; ix++)
		infile >> gpoint[ix].x >> gpoint[ix].y;

	for(ix=1; ix < NCELL+1; ix++)
		for(iy=0; iy<4; iy++) 
			infile >> gcell[ix].pn[iy];
        
	//for(iy=1; iy<=Ny4grd+2; iy++)
	for(iy=1; iy<=Ny; iy++)
	{
	//	for(ix=1; ix<=Nx4grd+2; ix++)
	for(ix=1; ix<=Nx; ix++)
		{
			//bgrid[iy-1][ix-1]=gcell[(ix-1)*(Ny4grd+2)+Ny4grd+2-(iy-1)];
			bgrid[iy-1][ix-1]=gcell[(ix-1)*Ny+Ny-(iy-1)];
		}
	}
	infile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3240
leaq 0x18b75(%rip), %rsi     # 0x1d088
movq %rbx, %rdi
movl $0x8, %edx
callq 0x3140
movl $0x18, %r14d
movq %rsp, %rbx
movq 0x1fd70(%rip), %rax     # 0x242a0
leaq (%rax,%r14), %rsi
addq $-0x8, %rsi
movq %rbx, %rdi
callq 0x3150
movq 0x1fd59(%rip), %rsi     # 0x242a0
addq %r14, %rsi
movq %rax, %rdi
callq 0x3150
addq $0x10, %r14
cmpq $0x150618, %r14         # imm = 0x150618
jne 0x4529
movl $0x1, %r14d
movl $0x10, %r15d
movq %rsp, %rbx
xorl %r12d, %r12d
movq 0x1fd30(%rip), %rsi     # 0x242a8
addq %r15, %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x3130
addq $0x4, %r12
cmpq $0x10, %r12
jne 0x4571
incq %r14
addq $0x10, %r15
cmpq $0x14e17, %r14          # imm = 0x14E17
jne 0x456e
movq 0x1fcf1(%rip), %rax     # 0x24298
movl $0x410, %ecx            # imm = 0x410
addq 0x1fcf5(%rip), %rcx     # 0x242a8
movl $0x1, %edx
movq $-0x7b0, %rsi           # imm = 0xF850
movq %rcx, %rdi
movups (%rdi), %xmm0
movups %xmm0, 0x7b0(%rax,%rsi)
addq $0x410, %rdi            # imm = 0x410
addq $0x10, %rsi
jne 0x45c2
incq %rdx
addq $-0x10, %rcx
addq $0x7b0, %rax            # imm = 0x7B0
cmpq $0x42, %rdx
jne 0x45b8
movq %rsp, %rdi
callq 0x3070
movq %rsp, %rdi
callq 0x3080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4610
jmp 0x4610
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/bodygridclass.cpp
// Function: bodygridclass::bodygridclass(double, double)
bodygridclass::bodygridclass(double hhx, double hhy)
{
    //   pmvx=NULL;
    //   pmvy=NULL;

    flag=0;
    exflag=-1;
    level=0;//�������ڵĲ��� 
    reflag=0;//�Ƿ�����;0-δ����,1-�Ѽ���
    coflag=false;//�ж������Ƿ��ֻ���0-δ�ֻ�,1-�Ѵֻ�
    NOparent=0u;//��ʼ����������
    NOchildren=0;//��������Ԫ���������еı���
    parent=NULL; 
    bAvg=false;
    tcur=0.0; 
    tdiv=0.0;
    pio=0.0;
    trb=false;
    trbamr=false;
    kxq=kxrcf=0.0;
    maxqp=inlen=0.0;
    mvflg=false;
    vorM=0.0;
    //	struct bodygrid *children[4];

   // p_node=NULL;
    for(int m=0; m<4; ++m)  children[m]=NULL;

    for(int i=0; i<4; i++) { 
        for(int j=0; j<6; j++){
#ifdef RES_SMOOTH
            resd0[i][j]=resd1[i][j]=0.0;
#endif
            residual[i][j]=dof[i][j]=dof0[i][j]=0.0;
        }
    }
    set_invM(hhx,hhy);
}

// Assembly:
movl $0xffff0000, 0x1b0(%rdi) # imm = 0xFFFF0000
xorl %eax, %eax
movw %ax, 0x1f8(%rdi)
movw %ax, 0x1fc(%rdi)
movb %al, 0x1fe(%rdi)
movl $0x0, 0x200(%rdi)
movw %ax, 0x204(%rdi)
movb %al, 0x206(%rdi)
movw %ax, 0x210(%rdi)
movb %al, 0x1b4(%rdi)
movq $0x0, 0x208(%rdi)
leaq 0x30(%rdi), %rcx
xorps %xmm2, %xmm2
movups %xmm2, 0x218(%rdi)
movups %xmm2, 0x228(%rdi)
movups %xmm2, 0x238(%rdi)
movups %xmm2, 0x248(%rdi)
movups %xmm2, 0x258(%rdi)
movups %xmm2, 0x268(%rdi)
xorl %edx, %edx
movups %xmm2, 0xc0(%rcx,%rdx,8)
movups %xmm2, (%rcx,%rdx,8)
movups %xmm2, 0x270(%rcx,%rdx,8)
addq $0x2, %rdx
cmpq $0x6, %rdx
jne 0x476a
incq %rax
addq $0x30, %rcx
cmpq $0x4, %rax
jne 0x4768
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x188af(%rip), %xmm2    # 0x1d050
divpd %xmm0, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
movhpd %xmm2, 0x10(%rdi)
movapd 0x188a2(%rip), %xmm2    # 0x1d060
divpd %xmm0, %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x18(%rdi)
movhpd %xmm2, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: Vec3D::cross(Vec3D const&)
Vec3D Vec3D::cross(const Vec3D &right) {
	Vec3D temp;
	temp.comp[0]=comp[1]*right.comp[2]-comp[2]*right.comp[1];
	temp.comp[1]=-comp[0]*right.comp[2]+comp[2]*right.comp[0];
	temp.comp[2]=comp[0]*right.comp[1]-comp[1]*right.comp[0];
	return temp;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movapd 0x187d8(%rip), %xmm2    # 0x1d0a0
movsd 0x10(%rsi), %xmm3
movapd %xmm3, %xmm4
xorpd %xmm2, %xmm4
xorpd %xmm0, %xmm2
movupd (%rdx), %xmm5
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulpd %xmm5, %xmm3
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
movsd 0x10(%rdx), %xmm4
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm2, %xmm4
addpd %xmm3, %xmm4
shufpd $0x1, %xmm4, %xmm4      # xmm4 = xmm4[1,0]
movupd %xmm4, (%rdi)
mulsd %xmm5, %xmm1
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
mulsd %xmm0, %xmm5
subsd %xmm1, %xmm5
movsd %xmm5, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/setflag.cpp
// Function: set_exFlag4All(int, pointxy*)
void set_exFlag4All(int nmpnt, PXYZ wallpt[]) 
{
    Node *current;
    OctCell *lsbl;
    OctCell *lsbl1[4];
    double x1,y1;
    int value, flg=0;

    double xcn[4],ycn[4];
    int flgn[4], sflg;	

    current = HeadListAllGrid;
    while(current != NULL)
    {
        lsbl = current->cell;

        x1=lsbl->xc1;
        y1=lsbl->yc1;
        flg=0;

        value = newFlagpoint(x1,y1,nmpnt, wallpt);
        if(value==0 ) {
            flg=-1;
            lsbl->flag=-1; ///
        }
        lsbl->exflag=flg;
        current=current->next;
    }
    //cout<<"it is ok\n";

    current = HeadListAllGrid;
    while(current != NULL)
    {
        lsbl = current->cell;
        if(lsbl->exflag==-1){
            if(current->flg!=6)
            {
                //-----------------------
                lsbl1[0]=SouthNeighbor(lsbl);
                lsbl1[1]=EastNeighbor(lsbl);	
                lsbl1[2]=NorthNeighbor(lsbl);
                lsbl1[3]=WestNeighbor(lsbl);	        
                sflg=0;
                for(int i=0; i<4; ++i) {      
                    if(lsbl1[i]->exflag==0) {
                        flg=2;
                        ++sflg;
                        break;
                    }
                }  

                if(sflg==0) flg=-1;      
                lsbl->exflag=flg;
            }
        }
        current=current->next;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x245e9(%rip), %r14     # 0x29610
movq (%r14), %r15
testq %r15, %r15
je 0x5103
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%r15), %r12
movsd 0x278(%r12), %xmm0
movsd 0x280(%r12), %xmm1
movl %ebp, %edi
movq %rbx, %rsi
callq 0xa6f2
testl %eax, %eax
je 0x5062
xorl %eax, %eax
jmp 0x5071
movw $0xffff, 0x1b0(%r12) # imm = 0xFFFF
movw $0xffff, %ax            # imm = 0xFFFF
movw %ax, 0x1b2(%r12)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x5038
movq (%r14), %r14
testq %r14, %r14
je 0x5103
movq 0x8(%r14), %rbx
cmpw $-0x1, 0x1b2(%rbx)
jne 0x50fd
cmpw $0x6, (%r14)
je 0x50fd
movq %rbx, %rdi
callq 0x8db8
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8d37
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8c30
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8cb4
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
cmpw $0x0, 0x1b2(%rcx)
je 0x50f2
incq %rax
cmpq $0x4, %rax
jne 0x50d5
movw $0xffff, %ax            # imm = 0xFFFF
jmp 0x50f6
movw $0x2, %ax
movw %ax, 0x1b2(%rbx)
movq 0x10(%r14), %r14
jmp 0x5086
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/outputgrid.cpp
// Function: output4restart()
void output4restart()
{
    Node *current;
    int i;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    ofstream fp1;

	string  str1=str0+"restart_data";
    fp1.open(str1.c_str());
    current = HeadListAllGrid;     
    while(current != NULL)
    {       
        pcell0 = current->cell;
        for(i=0;i<4;++i) fp1<<pcell0->dof[i][0]<<"  ";
        fp1<<"\n";
        current = current->next;
    }           
    fp1.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x28(%rsp), %rdi
callq 0x3340
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2100d(%rip), %rax     # 0x298a0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x8b04
leaq 0x14a81(%rip), %rsi     # 0x1d32f
leaq 0x8(%rsp), %rdi
callq 0x3390
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
callq 0x3050
leaq 0x20d3d(%rip), %rax     # 0x29610
movq (%rax), %r13
testq %r13, %r13
je 0x893d
leaq 0x28(%rsp), %rbx
leaq 0x15516(%rip), %r14     # 0x1ddfd
leaq 0x149ac(%rip), %r15     # 0x1d29a
movq 0x8(%r13), %rbp
movl $0x30, %r12d
movsd (%rbp,%r12), %xmm0
movq %rbx, %rdi
callq 0x3300
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3250
addq $0x30, %r12
cmpq $0xf0, %r12
jne 0x88f8
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3250
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x88ee
leaq 0x28(%rsp), %rdi
callq 0x32a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8963
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq 0x1b64e(%rip), %rax     # 0x23fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x31d0
leaq 0x120(%rsp), %rdi
callq 0x30b0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x89b2
movq %rax, %rbx
jmp 0x89d1
jmp 0x89b2
jmp 0x89b2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x89d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x28(%rsp), %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/outputgrid.cpp
// Function: read4restart()
void read4restart()
{
    Node *current;
    int i,j;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    ifstream fp1;
    fp1.open("IN//restart_data");
    current = HeadListAllGrid;     
    while(current != NULL)
    {       
        pcell0 = current->cell;
        for(i=0;i<4;++i){
            fp1>>pcell0->dof[i][0];
            pcell0->dof0[i][0]=pcell0->dof[i][0];
            for(j=1;j<nDOF;++j)
                pcell0->dof[i][j]=0.0;
        }

        current = current->next;
    }           
    fp1.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3240
leaq 0x14928(%rip), %rsi     # 0x1d32b
movq %rbx, %rdi
movl $0x8, %edx
callq 0x3140
leaq 0x20bf9(%rip), %rax     # 0x29610
movq (%rax), %r14
testq %r14, %r14
je 0x8a76
movq %rsp, %rbx
movq 0x8(%r14), %r15
movl $0x30, %r12d
leaq (%r15,%r12), %rsi
movq %rbx, %rdi
callq 0x3150
movsd (%r15,%r12), %xmm0
movsd %xmm0, 0xc0(%r15,%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15,%r12)
movups %xmm0, 0x18(%r15,%r12)
movq $0x0, 0x28(%r15,%r12)
addq $0x30, %r12
cmpq $0xf0, %r12
jne 0x8a2c
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x8a22
movq %rsp, %rdi
callq 0x3070
movq %rsp, %rdi
callq 0x3080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8a97
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: NorthNeighbor(bodygridclass*)
OctCell *NorthNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) 
	{
		return(&bodygrid[NOparent+Nx]);
	}
	
	NOchildren=pp->NOchildren;
	if(NOchildren==0) return(parent->children[3]);
    if(NOchildren==1) return(parent->children[2]);
    p=NorthNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==3) return(p->children[0]);
	else if(NOchildren==2) return(p->children[1]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8c5e
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8c61
movzwl 0x204(%rax), %ebx
cmpl $0x1, %ebx
je 0x8c83
testl %ebx, %ebx
jne 0x8c8c
movq 0x270(%rdi), %rax
jmp 0x8cb2
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1b672(%rip), %rcx     # 0x242e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $0x19f20, %rax          # imm = 0x19F20
jmp 0x8cb2
movq 0x268(%rdi), %rax
jmp 0x8cb2
callq 0x8c30
movq %rax, %rcx
movq 0x258(%rax), %rax
testq %rax, %rax
je 0x8caf
cmpw $0x3, %bx
je 0x8cb2
movq 0x260(%rcx), %rax
jmp 0x8cb2
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: WestNeighbor(bodygridclass*)
OctCell *WestNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;

	if(parent==NULL) return(&bodygrid[NOparent-1]);	

	NOchildren=pp->NOchildren;
	if(NOchildren==1) return(parent->children[0]);
    if(NOchildren==2) return(parent->children[3]);
    p=WestNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==0) return(p->children[1]);
	else if(NOchildren==3) return(p->children[2]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8ce3
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8ce6
movzwl 0x204(%rax), %ebx
cmpl $0x2, %ebx
je 0x8d08
cmpl $0x1, %ebx
jne 0x8d11
movq 0x258(%rdi), %rax
jmp 0x8d35
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1b5ed(%rip), %rcx     # 0x242e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $-0x360, %rax           # imm = 0xFCA0
jmp 0x8d35
movq 0x270(%rdi), %rax
jmp 0x8d35
callq 0x8cb4
cmpq $0x0, 0x258(%rax)
je 0x8d35
testw %bx, %bx
je 0x8d2e
movq 0x268(%rax), %rax
jmp 0x8d35
movq 0x260(%rax), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: EastNeighbor(bodygridclass*)
OctCell *EastNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) return(&bodygrid[NOparent+1]);	
	NOchildren=pp->NOchildren;
	if(NOchildren==0) return(parent->children[1]);
    if(NOchildren==3) return(parent->children[2]);
    p=EastNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==1) return(p->children[0]);
	else if(NOchildren==2) return(p->children[3]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8d65
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8d68
movzwl 0x204(%rax), %ebx
cmpl $0x3, %ebx
je 0x8d87
testl %ebx, %ebx
jne 0x8d90
movq 0x260(%rdi), %rax
jmp 0x8db6
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1b56b(%rip), %rcx     # 0x242e0
imulq $0x360, %rax, %rax      # imm = 0x360
addq (%rcx), %rax
addq $0x360, %rax            # imm = 0x360
jmp 0x8db6
movq 0x268(%rdi), %rax
jmp 0x8db6
callq 0x8d37
movq %rax, %rcx
movq 0x258(%rax), %rax
testq %rax, %rax
je 0x8db3
cmpw $0x1, %bx
je 0x8db6
movq 0x270(%rcx), %rax
jmp 0x8db6
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: SouthNeighbor(bodygridclass*)
OctCell *SouthNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) return(&bodygrid[NOparent-Nx]);	
	NOchildren=pp->NOchildren;
	if(NOchildren==3) return(parent->children[0]);
    if(NOchildren==2) return(parent->children[1]);
    p=SouthNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==0) return(p->children[3]);
	else if(NOchildren==1) return(p->children[2]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8de7
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8dea
movzwl 0x204(%rax), %ebx
cmpl $0x2, %ebx
je 0x8e0c
cmpl $0x3, %ebx
jne 0x8e15
movq 0x258(%rdi), %rax
jmp 0x8e39
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1b4e9(%rip), %rcx     # 0x242e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $-0x19f20, %rax         # imm = 0xFFFE60E0
jmp 0x8e39
movq 0x260(%rdi), %rax
jmp 0x8e39
callq 0x8db8
cmpq $0x0, 0x258(%rax)
je 0x8e39
testw %bx, %bx
je 0x8e32
movq 0x268(%rax), %rax
jmp 0x8e39
movq 0x270(%rax), %rax
popq %rbx
retq
nop