LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: show_scaled_lla()
void show_scaled_lla()
{
   // start scaled lla mode (if enabled) once valid lat/lon info received
   if(NO_SATS) return;

   if(1 && (lat && lon) && (have_valid_lla == 0)) {  // we now have valid lat/lon
      new_queue(RESET_ALL_QUEUES, 6466); // clear the queues so autoscale_lla does not crash
      have_valid_lla = 1;
      min_q_lat = max_q_lat = lat*RAD_TO_DEG;
      min_q_lon = max_q_lon = lon*RAD_TO_DEG;
      if(autoscale_lla) {
         change_lla_scale();
         rebuild_lla_plot(0);
         need_redraw = 4344;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d2a25(%rip), %rcx    # 0x277ab0
movabsq $0x105b8b0400, %rax     # imm = 0x105B8B0400
andq (%rcx), %rax
cmpq $0x0, %rax
jne 0xa50d2
leaq 0x1d510b(%rip), %rax    # 0x27a1b0
cmpl $0x0, (%rax)
je 0xa50b6
leaq 0x2c74f3(%rip), %rax    # 0x36c5a4
cmpl $0x0, (%rax)
je 0xa50d2
leaq 0x1d29f3(%rip), %rax    # 0x277ab0
cmpq $0x400000, (%rax)       # imm = 0x400000
jne 0xa50d7
leaq 0x2c7ac7(%rip), %rax    # 0x36cb94
cmpl $0x0, (%rax)
jne 0xa50d7
jmp 0xa51b2
leaq 0x2c70d2(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa50f2
jp 0xa50f2
jmp 0xa51b2
leaq 0x2c70bf(%rip), %rax    # 0x36c1b8
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa510d
jp 0xa510d
jmp 0xa51b2
leaq 0x2c7390(%rip), %rax    # 0x36c4a4
cmpl $0x0, (%rax)
jne 0xa51b2
movl $0x7, %edi
movl $0x1942, %esi           # imm = 0x1942
callq 0x14df0
leaq 0x2c7371(%rip), %rax    # 0x36c4a4
movl $0x1, (%rax)
movsd 0xca03f(%rip), %xmm0    # 0x16f180
leaq 0x2c7068(%rip), %rax    # 0x36c1b0
mulsd (%rax), %xmm0
leaq 0x2c7095(%rip), %rax    # 0x36c1e8
movsd %xmm0, (%rax)
leaq 0x2c7082(%rip), %rax    # 0x36c1e0
movsd %xmm0, (%rax)
movsd 0xca016(%rip), %xmm0    # 0x16f180
leaq 0x2c7047(%rip), %rax    # 0x36c1b8
mulsd (%rax), %xmm0
leaq 0x2c707c(%rip), %rax    # 0x36c1f8
movsd %xmm0, (%rax)
leaq 0x2c7069(%rip), %rax    # 0x36c1f0
movsd %xmm0, (%rax)
leaq 0x2f5302(%rip), %rax    # 0x39a494
cmpl $0x0, (%rax)
je 0xa51b0
callq 0x15b5d0
xorl %edi, %edi
callq 0x15b8f0
leaq 0x1d287a(%rip), %rax    # 0x277a24
movl $0x10f8, (%rax)         # imm = 0x10F8
jmp 0xa51b2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: update_plot_data()
void update_plot_data()
{
   // add the latest data to the plot queue and update the screen
   if(have_time && (pause_data == 0)) {
      if(continuous_scroll) update_plot(REFRESH_SCREEN);
      else if((all_adevs == SINGLE_ADEVS) || mixed_adevs) update_plot(REFRESH_SCREEN);
      else if(all_adevs) update_plot(REFRESH_SCREEN);
      else update_plot(NO_REFRESH);

      if(first_sample) {
         if(rcvr_type == SCPI_RCVR) ;
         else if(rcvr_type == UCCM_RCVR) ;
         else {
            if(discipline_mode == DIS_MODE_DISABLED) osc_discipline = 0;
            else                                     osc_discipline = 1;

            if(discipline_mode == DIS_MODE_MANUAL_HOLD) user_holdover = 1;
            else                                        user_holdover = 0;
         }

         if((all_adevs == SINGLE_ADEVS) || mixed_adevs) {
            draw_plot(REFRESH_SCREEN);
         }

         first_sample = 0;
      }
   }
   else {
      refresh_page();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f8d61(%rip), %rax    # 0x29e0bc
cmpb $0x0, (%rax)
je 0xa5486
leaq 0x1d50a9(%rip), %rax    # 0x27a414
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa5486
leaq 0x1d522a(%rip), %rax    # 0x27a5a8
cmpb $0x0, (%rax)
je 0xa538f
movl $0x1, %edi
callq 0x25020
jmp 0xa53d9
leaq 0x1f6b88(%rip), %rax    # 0x29bf1e
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xa53aa
leaq 0x1f6b78(%rip), %rax    # 0x29bf1d
cmpb $0x0, (%rax)
je 0xa53b6
movl $0x1, %edi
callq 0x25020
jmp 0xa53d7
leaq 0x1f6b61(%rip), %rax    # 0x29bf1e
cmpb $0x0, (%rax)
je 0xa53ce
movl $0x1, %edi
callq 0x25020
jmp 0xa53d5
xorl %edi, %edi
callq 0x25020
jmp 0xa53d7
jmp 0xa53d9
leaq 0x1f8cd4(%rip), %rax    # 0x29e0b4
cmpb $0x0, (%rax)
je 0xa5484
leaq 0x1d26c0(%rip), %rax    # 0x277ab0
cmpq $0x10, (%rax)
jne 0xa53f8
jmp 0xa5455
leaq 0x1d26b1(%rip), %rax    # 0x277ab0
cmpq $0x8, (%rax)
jne 0xa5407
jmp 0xa5453
leaq 0x2c7269(%rip), %rax    # 0x36c677
movzbl (%rax), %eax
cmpl $0x6, %eax
jne 0xa5422
leaq 0x2c7257(%rip), %rax    # 0x36c674
movb $0x0, (%rax)
jmp 0xa542c
leaq 0x2c724b(%rip), %rax    # 0x36c674
movb $0x1, (%rax)
leaq 0x2c7244(%rip), %rax    # 0x36c677
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0xa5447
leaq 0x2c71f2(%rip), %rax    # 0x36c634
movb $0x1, (%rax)
jmp 0xa5451
leaq 0x2c71e6(%rip), %rax    # 0x36c634
movb $0x0, (%rax)
jmp 0xa5453
jmp 0xa5455
leaq 0x1f6ac2(%rip), %rax    # 0x29bf1e
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xa5470
leaq 0x1f6ab2(%rip), %rax    # 0x29bf1d
cmpb $0x0, (%rax)
je 0xa547a
movl $0x1, %edi
callq 0x24e80
leaq 0x1f8c33(%rip), %rax    # 0x29e0b4
movb $0x0, (%rax)
jmp 0xa548b
callq 0xb0d0
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: plank(double, double)
double plank(double t, double y)
{
double f;

// This routine used Plank's equation to calculate the energy at wavelength
// y (in namometers) of a black body at temperature t (in degrees K)

   y *= 1.0E-9;     // convert wavelenth to meters
   f = (2.0*PI*HH*CC*CC) /
       ((y*y*y*y*y) * (exp((HH*CC) / (KK*y*t)) - 1.0));
   f /= 1.0E6;      // normalize to standard units
//printf("T=%f  y=%g  f=%g\n", t,y,f);
   return f;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0xc5e1e(%rip), %xmm0    # 0x16f168
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xd9a36(%rip), %xmm1    # 0x182db0
mulsd -0x10(%rbp), %xmm1
mulsd -0x8(%rbp), %xmm1
movsd 0xd9a1c(%rip), %xmm0    # 0x182da8
divsd %xmm1, %xmm0
callq 0x96d0
movsd -0x20(%rbp), %xmm1
movsd 0xc5cc6(%rip), %xmm2    # 0x16f068
subsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
movsd 0xd99ee(%rip), %xmm0    # 0x182da0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0xc5c78(%rip), %xmm1    # 0x16f040
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_batt_pwm(unsigned short)
void set_batt_pwm(u16 pwm)
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x06);
   send_word(pwm);
   send_tsip_end();

   if(pwm == 0) {    // cancel alarm timers
      alarm_time = alarm_date = 0;
      egg_timer = 0;
      repeat_egg = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
leaq 0x1f3fa8(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xaa180
jmp 0xaa1dd
movl $0xdc, %edi
callq 0x824f0
movl $0x6, %edi
callq 0x7b210
movzwl -0x2(%rbp), %edi
callq 0x7b4b0
callq 0x82590
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0xaa1dd
leaq 0x2c2f5a(%rip), %rax    # 0x36d10c
movl $0x0, (%rax)
leaq 0x2c2f3d(%rip), %rax    # 0x36d0fc
movl $0x0, (%rax)
leaq 0x2c2f1c(%rip), %rax    # 0x36d0e8
movq $0x0, (%rax)
leaq 0x2c2f1e(%rip), %rax    # 0x36d0f8
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: end_sweep()
void end_sweep()
{
   cc_mode = 0;
   sweep_stop = 0.0F;
   sweep_val = 0.0F;
   cc_state = 0;
   if(update_stop) {
      pause_data = 1;
      view_all(1);
      need_redraw = 2011;
   }
   update_stop = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2c1e6d(%rip), %rax    # 0x36c068
movb $0x0, (%rax)
leaq 0x2c1ea3(%rip), %rax    # 0x36c0a8
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x2c1e8d(%rip), %rax    # 0x36c0a0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x2c1e48(%rip), %rax    # 0x36c069
movb $0x0, (%rax)
leaq 0x2c1e8d(%rip), %rax    # 0x36c0b8
cmpl $0x0, (%rax)
je 0xaa251
leaq 0x1d01dd(%rip), %rax    # 0x27a414
movb $0x1, (%rax)
movl $0x1, %edi
callq 0x42620
leaq 0x1cd7d9(%rip), %rax    # 0x277a24
movl $0x7db, (%rax)          # imm = 0x7DB
leaq 0x2c1e60(%rip), %rax    # 0x36c0b8
movl $0x0, (%rax)
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: request_luxor_ver()
void request_luxor_ver()
{
   if(luxor == 0) return;
   if(no_poll) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x00);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f32e3(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xaae45
jmp 0xaae69
leaq 0x2eb3b4(%rip), %rax    # 0x396200
cmpb $0x0, (%rax)
je 0xaae53
jmp 0xaae69
movl $0xdc, %edi
callq 0x824f0
xorl %edi, %edi
callq 0x7b210
callq 0x82590
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: reset_luxor_wdt(unsigned char)
void reset_luxor_wdt(u08 flag)
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x09);
   send_byte(flag);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
leaq 0x1f1129(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xacfff
jmp 0xad021
movl $0xdc, %edi
callq 0x824f0
movl $0x9, %edi
callq 0x7b210
movzbl -0x1(%rbp), %edi
callq 0x7b210
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_luxor_config()
void get_luxor_config()
{
   if(luxor == 0) return;

   batt_lvc = tsip_single();
   batt_hvc = tsip_single(); 
   batt_ovc = tsip_single(); 
   batt_watts = tsip_single();
   load_lvc = tsip_single(); 
   load_hvc = tsip_single(); 
   load_ovc = tsip_single(); 
   load_watts = tsip_single();
   auxv_lvc = tsip_single(); 
   auxv_hvc = tsip_single(); 
   tc1_ovt = tsip_single(); 
   tc2_ovt = tsip_single(); 
   msg_timeout = tsip_single();

   lux1_time = (u08) tsip_single();
   lux2_time = (u08) tsip_single();
   emis1 = tsip_single(); 
   emis2 = tsip_single(); 

   batt_pwm_res = tsip_byte();
   set_pwm_step();
   check_tsip_end(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f10e3(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad048
jmp 0xad1bb
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd2a8(%rip), %rax    # 0x27a300
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd28c(%rip), %rax    # 0x27a2f8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd270(%rip), %rax    # 0x27a2f0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd274(%rip), %rax    # 0x27a308
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd238(%rip), %rax    # 0x27a2e0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd21c(%rip), %rax    # 0x27a2d8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd200(%rip), %rax    # 0x27a2d0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd204(%rip), %rax    # 0x27a2e8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd220(%rip), %rax    # 0x27a318
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd204(%rip), %rax    # 0x27a310
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd200(%rip), %rax    # 0x27a320
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd1f4(%rip), %rax    # 0x27a328
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd1e8(%rip), %rax    # 0x27a330
movsd %xmm0, (%rax)
callq 0x7a860
cvttss2si %xmm0, %eax
movb %al, %cl
leaq 0x2bee92(%rip), %rax    # 0x36bff0
movb %cl, (%rax)
callq 0x7a860
cvttss2si %xmm0, %eax
movb %al, %cl
leaq 0x2bee7f(%rip), %rax    # 0x36bff1
movb %cl, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2bee3c(%rip), %rax    # 0x36bfc0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2bee30(%rip), %rax    # 0x36bfc8
movsd %xmm0, (%rax)
callq 0x7a510
movb %al, %cl
leaq 0x2bee4a(%rip), %rax    # 0x36bff4
movb %cl, (%rax)
callq 0xad3e0
movl $0x1, %edi
callq 0x7aee0
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_luxor_cal()
void get_luxor_cal()
{
   if(luxor == 0) return;

   vref_m = tsip_single();
   vref_b = tsip_single();
   temp1_m = tsip_single();
   temp1_b = tsip_single();
   temp2_m = tsip_single();
   temp2_b = tsip_single();
   vcal_m = tsip_single();
   vcal_b = tsip_single();
   batti_m = tsip_single();
   batti_b = tsip_single();
   ledi_m = tsip_single();
   ledi_b = tsip_single();
   lux1_m = tsip_single();
   lux1_b = tsip_single();
   lux2_m = tsip_single();
   lux2_b = tsip_single();
   adc2_m = tsip_single();
   adc2_b = tsip_single();
   rb_m = tsip_single();
   rb_b = tsip_single();

   check_tsip_end(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f0f53(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad1d8
jmp 0xad372
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd158(%rip), %rax    # 0x27a340
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd14c(%rip), %rax    # 0x27a348
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd140(%rip), %rax    # 0x27a350
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd134(%rip), %rax    # 0x27a358
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd128(%rip), %rax    # 0x27a360
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd11c(%rip), %rax    # 0x27a368
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd110(%rip), %rax    # 0x27a370
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd104(%rip), %rax    # 0x27a378
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0f8(%rip), %rax    # 0x27a380
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0ec(%rip), %rax    # 0x27a388
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0e0(%rip), %rax    # 0x27a390
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0d4(%rip), %rax    # 0x27a398
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0c8(%rip), %rax    # 0x27a3a0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0bc(%rip), %rax    # 0x27a3a8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0b0(%rip), %rax    # 0x27a3b0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd0a4(%rip), %rax    # 0x27a3b8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd098(%rip), %rax    # 0x27a3c0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd08c(%rip), %rax    # 0x27a3c8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd080(%rip), %rax    # 0x27a3d0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x1cd074(%rip), %rax    # 0x27a3d8
movsd %xmm0, (%rax)
movl $0x1, %edi
callq 0x7aee0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_luxor_sens(unsigned char, unsigned char)
void set_luxor_sens(u08 lux1, u08 lux2)
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x03);
   send_byte(lux1);
   send_byte(lux2);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
leaq 0x1f0d83(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad3a5
jmp 0xad3d0
movl $0xdc, %edi
callq 0x824f0
movl $0x3, %edi
callq 0x7b210
movzbl -0x1(%rbp), %edi
callq 0x7b210
movzbl -0x2(%rbp), %edi
callq 0x7b210
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_pwm_step()
void set_pwm_step()
{
   if(batt_pwm_res == 8) PWM_STEP = (256.0F / 65536.0F);
   else if(batt_pwm_res == 9) PWM_STEP = (128.0F / 65536.0F);
   else { 
      PWM_STEP = (64.0F / 65536.0F);
      batt_pwm_res = 10;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2bec09(%rip), %rax    # 0x36bff4
movzbl (%rax), %eax
cmpl $0x8, %eax
jne 0xad408
leaq 0x2bebfe(%rip), %rax    # 0x36bff8
movsd 0xd5bc6(%rip), %xmm0    # 0x182fc8
movsd %xmm0, (%rax)
jmp 0xad44b
leaq 0x2bebe5(%rip), %rax    # 0x36bff4
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0xad42c
leaq 0x2bebda(%rip), %rax    # 0x36bff8
movsd 0xd5b9a(%rip), %xmm0    # 0x182fc0
movsd %xmm0, (%rax)
jmp 0xad449
leaq 0x2bebc5(%rip), %rax    # 0x36bff8
movsd 0xc1dbd(%rip), %xmm0    # 0x16f1f8
movsd %xmm0, (%rax)
leaq 0x2bebae(%rip), %rax    # 0x36bff4
movb $0xa, (%rax)
jmp 0xad44b
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_luxor_config()
void set_luxor_config()
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x07);
   send_single((float) batt_lvc);
   send_single((float) batt_hvc);
   send_single((float) batt_ovc);
   send_single((float) batt_watts);
   send_single((float) load_lvc);
   send_single((float) load_hvc);
   send_single((float) load_ovc);
   send_single((float) load_watts);
   send_single((float) auxv_lvc);
   send_single((float) auxv_hvc);
   send_single((float) tc1_ovt);
   send_single((float) tc2_ovt);
   send_single((float) msg_timeout);

   send_single((float) lux1_time);
   send_single((float) lux2_time);
   send_single((float) emis1);
   send_single((float) emis2);

   send_byte(batt_pwm_res);
   send_tsip_end();

   set_pwm_step();

   Sleep(500);   // !!!!!! allow time for message to be processed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f0cc3(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad468
jmp 0xad5f1
movl $0xdc, %edi
callq 0x824f0
movl $0x7, %edi
callq 0x7b210
leaq 0x1cce7d(%rip), %rax    # 0x27a300
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cce61(%rip), %rax    # 0x27a2f8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cce45(%rip), %rax    # 0x27a2f0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cce49(%rip), %rax    # 0x27a308
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cce0d(%rip), %rax    # 0x27a2e0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdf1(%rip), %rax    # 0x27a2d8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdd5(%rip), %rax    # 0x27a2d0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdd9(%rip), %rax    # 0x27a2e8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdf5(%rip), %rax    # 0x27a318
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdd9(%rip), %rax    # 0x27a310
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdd5(%rip), %rax    # 0x27a320
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdc9(%rip), %rax    # 0x27a328
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccdbd(%rip), %rax    # 0x27a330
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x2bea69(%rip), %rax    # 0x36bff0
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
callq 0x7b600
leaq 0x2bea57(%rip), %rax    # 0x36bff1
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
callq 0x7b600
leaq 0x2bea13(%rip), %rax    # 0x36bfc0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x2bea07(%rip), %rax    # 0x36bfc8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x2bea1f(%rip), %rax    # 0x36bff4
movzbl (%rax), %edi
callq 0x7b210
callq 0x82590
callq 0xad3e0
movl $0x1f4, %edi            # imm = 0x1F4
callq 0xb8b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_luxor_cal()
void set_luxor_cal()
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x11);
   send_single((float) vref_m);
   send_single((float) vref_b);
   send_single((float) temp1_m);
   send_single((float) temp1_b);
   send_single((float) temp2_m);
   send_single((float) temp2_b);
   send_single((float) vcal_m);
   send_single((float) vcal_b);
   send_single((float) batti_m);
   send_single((float) batti_b);
   send_single((float) ledi_m);
   send_single((float) ledi_b);
   send_single((float) lux1_m);
   send_single((float) lux1_b);
   send_single((float) lux2_m);
   send_single((float) lux2_b);
   send_single((float) adc2_m);
   send_single((float) adc2_b);
   send_single((float) rb_m);
   send_single((float) rb_b);
   send_tsip_end();

   Sleep(500);   // !!!!!! allow time for message to be processed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f0b13(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad618
jmp 0xad7cb
movl $0xdc, %edi
callq 0x824f0
movl $0x11, %edi
callq 0x7b210
leaq 0x1ccd0d(%rip), %rax    # 0x27a340
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccd01(%rip), %rax    # 0x27a348
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cccf5(%rip), %rax    # 0x27a350
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccce9(%rip), %rax    # 0x27a358
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cccdd(%rip), %rax    # 0x27a360
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cccd1(%rip), %rax    # 0x27a368
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cccc5(%rip), %rax    # 0x27a370
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cccb9(%rip), %rax    # 0x27a378
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1cccad(%rip), %rax    # 0x27a380
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccca1(%rip), %rax    # 0x27a388
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc95(%rip), %rax    # 0x27a390
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc89(%rip), %rax    # 0x27a398
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc7d(%rip), %rax    # 0x27a3a0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc71(%rip), %rax    # 0x27a3a8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc65(%rip), %rax    # 0x27a3b0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc59(%rip), %rax    # 0x27a3b8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc4d(%rip), %rax    # 0x27a3c0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc41(%rip), %rax    # 0x27a3c8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc35(%rip), %rax    # 0x27a3d0
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
leaq 0x1ccc29(%rip), %rax    # 0x27a3d8
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
callq 0x82590
movl $0x1f4, %edi            # imm = 0x1F4
callq 0xb8b0
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_luxor_runtime(unsigned int)
void set_luxor_runtime(u32 seconds)
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x0A);
   send_dword(seconds);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x1f093c(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad7ec
jmp 0xad80d
movl $0xdc, %edi
callq 0x824f0
movl $0xa, %edi
callq 0x7b210
movl -0x4(%rbp), %edi
callq 0x7b520
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_luxor_delay(unsigned short)
void set_luxor_delay(u16 msecs)
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x0B);
   send_word(msecs);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
leaq 0x1f08e8(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad840
jmp 0xad862
movl $0xdc, %edi
callq 0x824f0
movl $0xb, %edi
callq 0x7b210
movzwl -0x2(%rbp), %edi
callq 0x7b4b0
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_emissivity(double, double)
void set_emissivity(DATA_SIZE em1, DATA_SIZE em2)
{
   if(luxor) {
      send_tsip_start(LUXOR_ID); 
      send_byte(0x04);
      send_single((float) em1);
      send_single((float) em2);
      send_tsip_end();
   }
   else if((rcvr_type == THERMO_RCVR) && (enviro_type == LFS_ENVIRO) && (enviro_sensors & ENV_EMIS)) {
      sprintf(out, "PEMIS%d\r", (int) (em1*100.0));
      send_enviro_cmd(out, RCVR_PORT);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq 0x1f04d5(%rip), %rax    # 0x29e11e
cmpb $0x0, (%rax)
je 0xadc85
movl $0xdc, %edi
callq 0x824f0
movl $0x4, %edi
callq 0x7b210
movsd -0x8(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
movsd -0x10(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7b600
callq 0x82590
jmp 0xadced
leaq 0x1c9e24(%rip), %rax    # 0x277ab0
cmpq $0x80000, (%rax)        # imm = 0x80000
jne 0xadceb
leaq 0x1c9e58(%rip), %rax    # 0x277af4
cmpl $0x3, (%rax)
jne 0xadceb
leaq 0x1c9e58(%rip), %rax    # 0x277b00
movl (%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0xadceb
movsd 0xc1394(%rip), %xmm0    # 0x16f050
mulsd -0x8(%rbp), %xmm0
cvttsd2si %xmm0, %edx
leaq 0x2ed734(%rip), %rdi    # 0x39b400
leaq 0xd80c3(%rip), %rsi     # 0x185d96
movb $0x0, %al
callq 0x9060
leaq 0x2ed71f(%rip), %rdi    # 0x39b400
movl $0xa, %esi
callq 0x855b0
jmp 0xadced
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_cal_mode(unsigned char)
void set_cal_mode(u08 cal_mode)
{
   if(luxor == 0) return;

   send_tsip_start(LUXOR_ID); 
   send_byte(0x05);
   send_byte(cal_mode);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
leaq 0x1f0409(%rip), %rax    # 0x29e11e
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xadd1f
jmp 0xadd41
movl $0xdc, %edi
callq 0x824f0
movl $0x5, %edi
callq 0x7b210
movzbl -0x1(%rbp), %edi
callq 0x7b210
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_unknown_msg(unsigned short)
void get_unknown_msg(u16 msg_id)
{
   if(msg_id == 0x13) {
      msg_id = get_next_tsip();
      if(log_comments && (log_stream & LOG_HEX_STREAM) && log_file) {
         fprintf(log_file, "#!! Message rejected: %02X\n      ", msg_id);
         if(log_flush_mode) fflush(log_file);
         kol = (-1);
      }
   }
   else {
      if(log_comments && (log_stream & LOG_HEX_STREAM) && log_file) {
         fprintf(log_file, "#!! Unknown message: id %02X:\n      ", msg_id);
         if(log_flush_mode) fflush(log_file);
         kol = (-1);
      }
   }

   tsip_rptr = tsip_wptr = 0;  // flush the tsip buffer
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x13, %eax
jne 0xae0f1
callq 0x7a380
movw %ax, -0x2(%rbp)
leaq 0x1ef56c(%rip), %rax    # 0x29d5f4
cmpb $0x0, (%rax)
je 0xae0ef
leaq 0x1ef55c(%rip), %rax    # 0x29d5f0
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xae0ef
leaq 0x1ef49b(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
je 0xae0ef
leaq 0x1ef48e(%rip), %rax    # 0x29d540
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0xd7cdf(%rip), %rsi     # 0x185d9f
movb $0x0, %al
callq 0x9550
leaq 0x1ef532(%rip), %rax    # 0x29d600
cmpl $0x0, (%rax)
je 0xae0e2
leaq 0x1ef466(%rip), %rax    # 0x29d540
movq (%rax), %rdi
callq 0x9430
leaq 0x1f005b(%rip), %rax    # 0x29e144
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xae161
leaq 0x1ef4fc(%rip), %rax    # 0x29d5f4
cmpb $0x0, (%rax)
je 0xae15f
leaq 0x1ef4ec(%rip), %rax    # 0x29d5f0
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xae15f
leaq 0x1ef42b(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
je 0xae15f
leaq 0x1ef41e(%rip), %rax    # 0x29d540
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0xd7c91(%rip), %rsi     # 0x185dc1
movb $0x0, %al
callq 0x9550
leaq 0x1ef4c2(%rip), %rax    # 0x29d600
cmpl $0x0, (%rax)
je 0xae152
leaq 0x1ef3f6(%rip), %rax    # 0x29d540
movq (%rax), %rdi
callq 0x9430
leaq 0x1effeb(%rip), %rax    # 0x29e144
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xae161
leaq 0x2e92ca(%rip), %rax    # 0x397432
movw $0x0, (%rax)
leaq 0x2e92c0(%rip), %rax    # 0x397434
movw $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: new_packet(int)
void new_packet(int redraw)
{
   ++packet_count;
   if(packet_count == 1L) {
      if(redraw) need_redraw = 3333;  // get rid of any "no serial..." message
   }

   if(timing_seen == 2) { // reset queues when second time message seen
      new_queue(RESET_ALL_QUEUES, 100);
      timing_seen = 3;
   }

   // NEW_RCVR
   if(need_queue_reset) {  // data has just started comming in... reset queues when importand plots have data
      if(rcvr_type == RFTG_RCVR) {  // reset queues after first few packets have arrived
         if(have_dac && have_temperature && have_pps_offset) { // all plots now have data
            new_queue(RESET_ALL_QUEUES, 222);
            need_queue_reset = 0;
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x1efd82(%rip), %rax    # 0x29e154
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1efd76(%rip), %rax    # 0x29e154
movl %ecx, (%rax)
leaq 0x1efd6d(%rip), %rax    # 0x29e154
movl (%rax), %eax
cmpq $0x1, %rax
jne 0xae404
cmpl $0x0, -0x4(%rbp)
je 0xae402
leaq 0x1c9628(%rip), %rax    # 0x277a24
movl $0xd05, (%rax)          # imm = 0xD05
jmp 0xae404
leaq 0x1efd4d(%rip), %rax    # 0x29e158
cmpl $0x2, (%rax)
jne 0xae42c
movl $0x7, %edi
movl $0x64, %esi
callq 0x14df0
leaq 0x1efd32(%rip), %rax    # 0x29e158
movl $0x3, (%rax)
leaq 0x1efd3d(%rip), %rax    # 0x29e170
cmpl $0x0, (%rax)
je 0xae48c
leaq 0x1c9671(%rip), %rax    # 0x277ab0
cmpq $0x400000, (%rax)       # imm = 0x400000
jne 0xae48a
leaq 0x2be08d(%rip), %rax    # 0x36c4dc
cmpl $0x0, (%rax)
je 0xae488
leaq 0x2bdfd1(%rip), %rax    # 0x36c42c
cmpl $0x0, (%rax)
je 0xae488
leaq 0x2bdfb1(%rip), %rax    # 0x36c418
cmpl $0x0, (%rax)
je 0xae488
movl $0x7, %edi
movl $0xde, %esi
callq 0x14df0
leaq 0x1efcee(%rip), %rax    # 0x29e170
movl $0x0, (%rax)
jmp 0xae48a
jmp 0xae48c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: start_msg_decode(int)
void start_msg_decode(int redraw)
{
   // prepare to decode a receiver message

   msg_fault = 0x00;
   tsip_rptr = 0;
   ticc_rptr = 0;
   enviro_rptr = 0;

   first_msg = 0;
   last_msg = msg_id;
   ++wakeup_tsip_msg; // we have seen a message
   tsip_error = 0;    // this flag gets set if we see something wrong in a message
   early_end = 0;
   new_packet(redraw);

   flush_debug();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x1efc9a(%rip), %rax    # 0x29e14c
movl $0x0, (%rax)
leaq 0x2e8f75(%rip), %rax    # 0x397434
movw $0x0, (%rax)
leaq 0x2e9f7d(%rip), %rax    # 0x398448
movl $0x0, (%rax)
leaq 0x2eaf80(%rip), %rax    # 0x399458
movl $0x0, (%rax)
leaq 0x2e7d24(%rip), %rax    # 0x396209
movb $0x0, (%rax)
leaq 0x1efc4d(%rip), %rax    # 0x29e13c
movzwl (%rax), %eax
movl %eax, 0x31caac(%rip)    # 0x3cafa4
leaq 0x1efc79(%rip), %rax    # 0x29e178
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x1efc6b(%rip), %rax    # 0x29e178
movq %rcx, (%rax)
leaq 0x1efc39(%rip), %rax    # 0x29e150
movl $0x0, (%rax)
movw $0x0, 0x31ca7a(%rip)    # 0x3cafa0
movl -0x4(%rbp), %edi
callq 0xae3c0
callq 0x798d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rt17_event()
void parse_rt17_event()
{
int source;
int port;
int tag;
double time;

   log_packet_id("Event");
   source = tsip_byte();
   port = tsip_byte();
   tag = tsip_word();
   time = tsip_double();  // msecs in GPS week
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xd6e22(%rip), %rdi     # 0x185e21
callq 0x7add0
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x4(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0xc(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x18(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rt17_rawdata(int)
void parse_rt17_rawdata(int msg)
{
int subcode;
int page;
int reply;
int flags;

   subcode = tsip_byte();
   page = tsip_byte();
   reply = tsip_byte();
   flags = tsip_byte();

   if     (subcode == 0x00) parse_rt17_realtime(flags);
   else if(subcode == 0x01) parse_rt17_posn(flags);
   else if(subcode == 0x02) parse_rt17_event();
   else if(subcode == 0x05) parse_rt17_raw5();
   else if(subcode == 0x06) parse_rt17_raw6();
   else if(subcode == 0x07) parse_rt17_enh_posn();
   else {
      sprintf(out, "RAWDATA 0x%02X:%02X", msg, subcode);
      log_packet_id(out);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0xc(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x10(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xb01b7
movl -0x14(%rbp), %edi
callq 0xafd20
jmp 0xb022c
cmpl $0x1, -0x8(%rbp)
jne 0xb01c7
movl -0x14(%rbp), %edi
callq 0xaedd0
jmp 0xb022a
cmpl $0x2, -0x8(%rbp)
jne 0xb01d4
callq 0xaeff0
jmp 0xb0228
cmpl $0x5, -0x8(%rbp)
jne 0xb01e1
callq 0xb00c0
jmp 0xb0226
cmpl $0x6, -0x8(%rbp)
jne 0xb01ee
callq 0xb00e0
jmp 0xb0224
cmpl $0x7, -0x8(%rbp)
jne 0xb01fb
callq 0xb0100
jmp 0xb0222
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x2eb1f8(%rip), %rdi    # 0x39b400
leaq 0xd5e16(%rip), %rsi     # 0x186025
movb $0x0, %al
callq 0x9060
leaq 0x2eb1e3(%rip), %rdi    # 0x39b400
callq 0x7add0
jmp 0xb0224
jmp 0xb0226
jmp 0xb0228
jmp 0xb022a
jmp 0xb022c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rt17_gsof(int)
void parse_rt17_gsof(int msg)
{
int reply;
int page;
int pages;

int subcode;
int len;

   reply = tsip_byte();
   page = tsip_byte();
   pages = tsip_byte();

   while(tsip_rptr < tsip_wptr) {  // parse the GSOF messages
      subcode = tsip_byte();
      len = tsip_byte();
      sprintf(out, "GSOF msg 0x%02X:%d", subcode, len);
      log_packet_id(out);
      // decode GSOF packets here
while(len--) tsip_byte();  // toots - skip payload bytes for now
break;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0xc(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x10(%rbp)
leaq 0x2e71c1(%rip), %rax    # 0x397434
movzwl (%rax), %eax
leaq 0x2e71b5(%rip), %rcx    # 0x397432
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0xb02da
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x14(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x2eb159(%rip), %rdi    # 0x39b400
leaq 0xd5d8b(%rip), %rsi     # 0x186039
movb $0x0, %al
callq 0x9060
leaq 0x2eb144(%rip), %rdi    # 0x39b400
callq 0x7add0
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0xb02d8
callq 0x7a510
jmp 0xb02c1
jmp 0xb02da
addq $0x20, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: is_numeric(char*)
int is_numeric(char *field)
{
unsigned i;

   // returns true if field starts with + - . or digit

   if(field[0] == 0) return 0;

   for(i=0; i<strlen(field); i++) {  // skip leading whitespace
      if(field[i] == ' ') ;
      else if(field[i] == '\t') ;
      else {  // first non-whitespace seen
         if(field[i] == '+') return 1;
         if(field[i] == '-') return 2;
         if(field[i] == '.') return 3;
         if((field[i] >= '0') && (field[i] <= '9')) return 4;
         if((field[i] == '.') && (field[i+1] >= '0') && (field[i+1] <= '9')) return 5;
         break;
      }
   }

   return 0;  // field is not a number
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xb0a94
movl $0x0, -0x4(%rbp)
jmp 0xb0bc0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9120
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xb0bb9
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0xb0ad0
jmp 0xb0ba9
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0xb0ae5
jmp 0xb0ba7
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0xb0b01
movl $0x1, -0x4(%rbp)
jmp 0xb0bc0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0xb0b1d
movl $0x2, -0x4(%rbp)
jmp 0xb0bc0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0xb0b39
movl $0x3, -0x4(%rbp)
jmp 0xb0bc0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0xb0b62
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0xb0b62
movl $0x4, -0x4(%rbp)
jmp 0xb0bc0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0xb0ba5
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0xb0ba5
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0xb0ba5
movl $0x5, -0x4(%rbp)
jmp 0xb0bc0
jmp 0xb0bb9
jmp 0xb0ba9
jmp 0xb0bab
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb0a9b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_nmea_lat()
void get_nmea_lat()
{
double deg;

   if(get_msg_field()) {
      deg = atof(msg_field);
      lat = (double) (int) (deg / 100.0);
      deg = deg - (lat * 100.0);
      deg /= 60.0;
      lat += deg;
      lat *= (PI / 180.0);
   }

   if(get_msg_field()) {
      if(msg_field[0] == 'S') lat = 0.0 - lat;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb1576
leaq 0x2e9763(%rip), %rdi    # 0x39ac20
callq 0x9480
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xbdb7c(%rip), %xmm1    # 0x16f050
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvtsi2sd %eax, %xmm0
leaq 0x2bacc9(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
movsd -0x8(%rbp), %xmm1
leaq 0x2bacb9(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xbdb36(%rip), %xmm2    # 0x16f050
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xbdae4(%rip), %xmm1    # 0x16f018
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
leaq 0x2bac67(%rip), %rax    # 0x36c1b0
addsd (%rax), %xmm0
leaq 0x2bac5c(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
movsd 0xc0130(%rip), %xmm0    # 0x171690
leaq 0x2bac49(%rip), %rax    # 0x36c1b0
mulsd (%rax), %xmm0
leaq 0x2bac3e(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb15aa
leaq 0x2e9699(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0xb15a8
xorps %xmm0, %xmm0
leaq 0x2bac17(%rip), %rax    # 0x36c1b0
subsd (%rax), %xmm0
leaq 0x2bac0c(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
jmp 0xb15aa
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_nmea_lon()
void get_nmea_lon()
{
double deg;

   if(get_msg_field()) {
      deg = atof(msg_field);
      lon = (double) (int) (deg / 100.0);
      deg = deg - (lon * 100.0);
      deg /= 60.0;
      lon += deg;
      lon *= (PI / 180.0);
   }

   if(get_msg_field()) {
      if(msg_field[0] == 'W') lon = 0.0 - lon;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb1686
leaq 0x2e9653(%rip), %rdi    # 0x39ac20
callq 0x9480
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xbda6c(%rip), %xmm1    # 0x16f050
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvtsi2sd %eax, %xmm0
leaq 0x2babc1(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
movsd -0x8(%rbp), %xmm1
leaq 0x2babb1(%rip), %rax    # 0x36c1b8
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xbda26(%rip), %xmm2    # 0x16f050
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xbd9d4(%rip), %xmm1    # 0x16f018
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
leaq 0x2bab5f(%rip), %rax    # 0x36c1b8
addsd (%rax), %xmm0
leaq 0x2bab54(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
movsd 0xc0020(%rip), %xmm0    # 0x171690
leaq 0x2bab41(%rip), %rax    # 0x36c1b8
mulsd (%rax), %xmm0
leaq 0x2bab36(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb16ba
leaq 0x2e9589(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x57, %eax
jne 0xb16b8
xorps %xmm0, %xmm0
leaq 0x2bab0f(%rip), %rax    # 0x36c1b8
subsd (%rax), %xmm0
leaq 0x2bab04(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
jmp 0xb16ba
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_nmea_alt()
void get_nmea_alt()
{
   if(get_msg_field()) {  //altitude
      alt = atoi(msg_field);
      get_msg_field();    // meters or feet
      if(msg_field[0] == 'F') alt = alt * FEET_PER_METER;
   }
   else get_msg_field();  // meters or feet
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb171d
leaq 0x2e954b(%rip), %rdi    # 0x39ac20
callq 0x95c0
cvtsi2sd %eax, %xmm0
leaq 0x2baadb(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
callq 0xb0bd0
leaq 0x2e952b(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x46, %eax
jne 0xb171b
movsd 0xbff2b(%rip), %xmm0    # 0x171630
leaq 0x2baab4(%rip), %rax    # 0x36c1c0
mulsd (%rax), %xmm0
leaq 0x2baaa9(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
jmp 0xb1722
callq 0xb0bd0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_nmea_date()
void get_nmea_date()
{
int date;

   // get a date field from a NMEA message

   if(rcvr_type == BRANDY_RCVR) {  // we use the brandywine time and date message
      get_msg_field();
   }
   else if(get_msg_field()) {
      date = atoi(msg_field);
      have_nmea_date = 0x07;     // we have day/month/year

      pri_day = day = (date / 10000);
      pri_month = month = ((date / 100) % 100);
      pri_year = ((date / 1) % 100);
      if(pri_year > TRUNC_YEAR) pri_year += 1900;
      else                      pri_year += 2000;
      year = pri_year;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1c61d1(%rip), %rax    # 0x277ab0
cmpq $0x40000, (%rax)        # imm = 0x40000
jne 0xb18f2
callq 0xb0bd0
jmp 0xb19ce
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb19cc
leaq 0x2e9319(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
leaq 0x1c89b2(%rip), %rax    # 0x27a2c8
movl $0x7, (%rax)
movl -0x4(%rbp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
movl %eax, %ecx
leaq 0x2bad84(%rip), %rax    # 0x36c6b4
movl %ecx, (%rax)
leaq 0x2badb3(%rip), %rax    # 0x36c6ec
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl $0x64, %ecx
cltd
idivl %ecx
leaq 0x2bad63(%rip), %rax    # 0x36c6b8
movl %edx, (%rax)
leaq 0x2bad92(%rip), %rax    # 0x36c6f0
movl %edx, (%rax)
movl -0x4(%rbp), %eax
movl $0x1, %ecx
cltd
idivl %ecx
movl $0x64, %ecx
cltd
idivl %ecx
leaq 0x2bad7a(%rip), %rax    # 0x36c6f4
movl %edx, (%rax)
leaq 0x2bad71(%rip), %rax    # 0x36c6f4
cmpl $0x50, (%rax)
jle 0xb19a2
leaq 0x2bad65(%rip), %rax    # 0x36c6f4
movl (%rax), %ecx
addl $0x76c, %ecx            # imm = 0x76C
leaq 0x2bad56(%rip), %rax    # 0x36c6f4
movl %ecx, (%rax)
jmp 0xb19ba
leaq 0x2bad4b(%rip), %rax    # 0x36c6f4
movl (%rax), %ecx
addl $0x7d0, %ecx            # imm = 0x7D0
leaq 0x2bad3c(%rip), %rax    # 0x36c6f4
movl %ecx, (%rax)
leaq 0x2bad33(%rip), %rax    # 0x36c6f4
movl (%rax), %ecx
leaq 0x2bacf2(%rip), %rax    # 0x36c6bc
movl %ecx, (%rax)
jmp 0xb19ce
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: check_nmea_date()
void check_nmea_date()
{
   // fake a date from the system clock if none seen from the GPS
   if(rcvr_type == BRANDY_RCVR) return;

   if(have_nmea_date != 0x07) {  // SV6_TYPE - has no date messages, use the system clock
      get_clock_time();
      year = pri_year = clk_year;
      month = pri_month = clk_month;
      day = pri_day = clk_day;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1c60c5(%rip), %rax    # 0x277ab0
cmpq $0x40000, (%rax)        # imm = 0x40000
jne 0xb19f6
jmp 0xb1a58
leaq 0x1c88cb(%rip), %rax    # 0x27a2c8
cmpl $0x7, (%rax)
je 0xb1a58
callq 0xa750
leaq 0x2bae9a(%rip), %rax    # 0x36c8a8
movl (%rax), %ecx
leaq 0x2bacdd(%rip), %rax    # 0x36c6f4
movl %ecx, (%rax)
leaq 0x2bac9c(%rip), %rax    # 0x36c6bc
movl %ecx, (%rax)
leaq 0x2bae77(%rip), %rax    # 0x36c8a0
movl (%rax), %ecx
leaq 0x2bacbe(%rip), %rax    # 0x36c6f0
movl %ecx, (%rax)
leaq 0x2bac7d(%rip), %rax    # 0x36c6b8
movl %ecx, (%rax)
leaq 0x2bae60(%rip), %rax    # 0x36c8a4
movl (%rax), %ecx
leaq 0x2bac9f(%rip), %rax    # 0x36c6ec
movl %ecx, (%rax)
leaq 0x2bac5e(%rip), %rax    # 0x36c6b4
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gpgll(int)
void parse_gpgll(int system)
{
double old_lat, old_lon,old_alt;

   old_lat = lat;
   old_lon = lon;
   old_alt = alt;

   get_nmea_lat();
   get_nmea_lon();
   get_nmea_alt();

   if(get_msg_field()) {  // status: A=valid  V=invalid
      if(msg_field[0] == 'V') {
         lat = old_lat;
         lon = old_lon;
         alt = old_alt;
      }
   }
   if(get_msg_field()) {  // mode: A=autonomus  D=differential  N=invalid
      if(msg_field[0] == 'N') {
         lat = old_lat;
         lon = old_lon;
         alt = old_alt;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2ba73e(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq 0x2ba736(%rip), %rax    # 0x36c1b8
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0x2ba72e(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0xb14a0
callq 0xb15b0
callq 0xb16c0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb1af5
leaq 0x2e9165(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x56, %eax
jne 0xb1af3
movsd -0x10(%rbp), %xmm0
leaq 0x2ba6e1(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
leaq 0x2ba6d9(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
leaq 0x2ba6d1(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
jmp 0xb1af5
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb1b40
leaq 0x2e911a(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0xb1b3e
movsd -0x10(%rbp), %xmm0
leaq 0x2ba696(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
leaq 0x2ba68e(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
leaq 0x2ba686(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
jmp 0xb1b40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)