LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_alarm_window(double)
void set_sro_alarm_window(double nsecs)
{
int val;

   if(read_only) return;

   if(nsecs < 0.0) nsecs = 0.0 - nsecs;
   nsecs += (SRO_TICK / 2.0);
   val = (int) (nsecs / SRO_TICK);
   if(val > 7499999) val = 7499999;
   sprintf(out, "AW%03d", val);
   queue_sro_cmd(out, SRO_AW_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab2c0(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bd60
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltsd %xmm1, %xmm2
subsd %xmm0, %xmm1
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd 0x9290d(%rip), %xmm2    # 0x11e698
divsd 0x7fc7d(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0x7270df, %edx         # imm = 0x7270DF
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b0478(%rip), %rbx    # 0x33c220
leaq 0x97b47(%rip), %rsi     # 0x1238f6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32c, %esi            # imm = 0x32C
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_track_window(double)
void set_sro_track_window(double nsecs)
{
int val;

   if(read_only) return;

   if(nsecs < 0.0) nsecs = 0.0 - nsecs;
   nsecs += (SRO_TICK / 2.0);
   val = (int) (nsecs / SRO_TICK);
   if(val > 255) val = 255;
   sprintf(out, "TW%03d", val);
   queue_sro_cmd(out, SRO_TW_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab23d(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bde3
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltsd %xmm1, %xmm2
subsd %xmm0, %xmm1
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd 0x9288a(%rip), %xmm2    # 0x11e698
divsd 0x7fbfa(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0xff, %edx
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b03f5(%rip), %rbx    # 0x33c220
leaq 0x97acb(%rip), %rsi     # 0x1238fd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32b, %esi            # imm = 0x32B
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_clock()
void set_sro_clock()
{

   if(read_only) return;

   sprintf(out, "DT%04d-%02d-%02d", pri_year,pri_month,pri_day);
   queue_sro_cmd(out, SRO_DT_MSG);

   sprintf(out, "TD%02d:%02d:%02d", pri_hours,pri_minutes,pri_seconds);
   queue_sro_cmd(out, SRO_TD_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab1ba(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8be66
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2816a1(%rip), %rax    # 0x30d514
movl (%rax), %edx
leaq 0x281694(%rip), %rax    # 0x30d510
movl (%rax), %ecx
leaq 0x281687(%rip), %rax    # 0x30d50c
movl (%rax), %r8d
leaq 0x2b0391(%rip), %rbx    # 0x33c220
leaq 0x97a6e(%rip), %rsi     # 0x123904
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x333, %esi            # imm = 0x333
callq 0x5ee52
leaq 0x281654(%rip), %rax    # 0x30d508
movl (%rax), %edx
leaq 0x281647(%rip), %rax    # 0x30d504
movl (%rax), %ecx
leaq 0x28163a(%rip), %rax    # 0x30d500
movl (%rax), %r8d
leaq 0x97a45(%rip), %rsi     # 0x123915
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x334, %esi            # imm = 0x334
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_user()
void parse_scpi_user()
{
int i;

   log_packet_id("scpi user msg");

   i = (int) sizeof(debug_text2)-20;
   if(i < (int) sizeof(nmea_msg)) nmea_msg[i] = 0;

   sprintf(debug_text2, "response to msg %d:%s", user_msg_num, nmea_msg);
   need_redraw = 543;  // why is this needed for X11?
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98e4d(%rip), %rdi     # 0x12501b
callq 0x58e77
leaq 0x2af656(%rip), %rcx    # 0x33b830
movb $0x0, 0x137(%rcx)
movl 0x2dfc2d(%rip), %edx    # 0x36be14
leaq 0x2b2902(%rip), %rdi    # 0x33eaf0
leaq 0x98e34(%rip), %rsi     # 0x125029
xorl %eax, %eax
callq 0x9060
leaq 0x18c641(%rip), %rax    # 0x218844
movl $0x21f, (%rax)          # imm = 0x21F
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sa35_freq(double)
void set_sa35_freq(double freq)
{
double val;

   // !!!!! placeholder

   if(read_only) return;

   if(freq > 2.00E-8) freq = 2.00E-8;
   if(freq < -2.00E-8) freq = -2.00E-8;

   val = freq / 1.0E-15;
   sprintf(out, "<FG%d>", (int) val);
   queue_sa35_cmd(out, SA35_DDS_CMD);

   BEEP(505);  // signal EEPROM write  piss3
}

// Assembly:
leaq 0x2aab88(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8c498
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd 0x7f542(%rip), %xmm1    # 0x10b9e8
minsd %xmm0, %xmm1
movsd 0x921f6(%rip), %xmm0    # 0x11e6a8
maxsd %xmm1, %xmm0
divsd 0x7cc6a(%rip), %xmm0    # 0x109128
cvttsd2si %xmm0, %edx
leaq 0x2afd57(%rip), %rbx    # 0x33c220
leaq 0x9747f(%rip), %rsi     # 0x12394f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x3eb, %esi            # imm = 0x3EB
callq 0x5ee52
movl $0x1f9, %edi            # imm = 0x1F9
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: decode_sa35_msg()
void decode_sa35_msg()
{
char c;
int i;

   start_msg_decode(0);

   nmea_msg[0] = 0;
   for(i=0; i<tsip_wptr; i++) {  // copy message from tsip buffer to nmea buffer
      c = tsip_byte();
      nmea_msg[i] = c;
      nmea_msg[i+1] = 0;
      if(i >= ((int)sizeof(nmea_msg)-12)) break;
   }
   msg_col = 0;     // index of next char to get from nmea buffer

   tsip_wptr = tsip_rptr = 0;
   tsip_sync = 0;

   // get the response from the reciver and pass it to (HOPEFULLY) the routine
   // that expects it...

   strupr(nmea_msg);

if(debug_file) fprintf(debug_file, "Decode msg %d:[%s]\n", polled_msg_id, nmea_msg);
//sprintf(debug_text, "Decode msg %d:[%s]", polled_msg_id, nmea_msg);


   sa35_msg_id = polled_msg_id;

   // !!!!! decode here

   i = get_norcvr_message();   // returns true if seconds just ticked
   poll_next_sa35();

   sa35_msg_id = 0;

   if(sim_file && sim_delay) {  // throttle sim file messages
      Sleep(sim_delay);
   }

   saw_rcvr_msg = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x7f47d
leaq 0x2af307(%rip), %r15    # 0x33b830
movb $0x0, (%r15)
leaq 0x2abd1e(%rip), %rbx    # 0x338252
leaq 0x1b2a35(%rip), %r12    # 0x23ef70
movzwl (%rbx), %eax
cmpq %rax, %r14
jae 0x8c56a
callq 0x587d1
cmpl $0x100, %eax            # imm = 0x100
jb 0x8c554
orb $0x8, (%r12)
movb %al, (%r14,%r15)
movb $0x0, 0x1(%r14,%r15)
incq %r14
cmpq $0x1f6, %r14            # imm = 0x1F6
jne 0x8c53b
leaq 0x2af6d3(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
leaq 0x2abcd6(%rip), %rax    # 0x338254
xorl %ecx, %ecx
movw %cx, (%rax)
movw %cx, (%rbx)
leaq 0x2abcc9(%rip), %rax    # 0x338256
movw %cx, (%rax)
leaq 0x2af299(%rip), %rdi    # 0x33b830
callq 0x9899
leaq 0x1b1ded(%rip), %rax    # 0x23e390
movq (%rax), %rdi
testq %rdi, %rdi
je 0x8c5c6
movl 0x2e064f(%rip), %edx    # 0x36cc00
leaq 0x9736e(%rip), %rsi     # 0x123926
leaq 0x2af271(%rip), %rcx    # 0x33b830
xorl %eax, %eax
callq 0x9560
movl 0x2e0634(%rip), %eax    # 0x36cc00
movl %eax, 0x2e063e(%rip)    # 0x36cc10
callq 0x82578
leaq 0x7d9dd(%rip), %rdi     # 0x109fbb
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x6e3bc
leaq 0x1b1dd1(%rip), %rax    # 0x23e3c0
cmpq $0x0, (%rax)
movl $0x0, 0x2e0613(%rip)    # 0x36cc10
setne %al
leaq 0x196ff9(%rip), %rcx    # 0x223600
movq (%rcx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8c61c
callq 0xaff7
leaq 0x1b297d(%rip), %rax    # 0x23efa0
movl $0x1, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_lpfrs_m()
void parse_lpfrs_m()
{
int hh;   // photocell voltage
int gg;   // Rb signal peak voltage
int ff;   // reserved
int ee;   // varactor voltage
int dd;   // EFC input voltage
int cc;   // lamp current
int bb;   // cell current
int aa;   // 90 MHz agc voltage
int i;

   log_packet_id("paramters");

   i = sscanf(nmea_msg, "%x %x %x %x %x %x %x %x", &hh,&gg,&ff,&ee,&dd,&cc,&bb,&aa);
   if(i != 8) {  // expected 8 values.  Loss of message sync?
      restart_prs_polling();
      return;
   }

   lpfrs_hh = ((double) (255-hh)) / 255.0 * 5.0;
   lpfrs_gg = ((double) gg) / 255.0 * 5.0;
   lpfrs_ff = ((double) ff);
   lpfrs_ee = ((double) ee) / 255.0 * 5.0;
   lpfrs_dd = ((double) dd) / 255.0 * 5.0;
   lpfrs_cc = ((double) (255-cc)) / 255.0 * 500.0;  // ma
   lpfrs_bb = ((double) (255-bb)) / 255.0 * 500.0;  // ma
   lpfrs_aa = ((double) gg) / 255.0 * 5.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x97318(%rip), %rdi     # 0x12395c
callq 0x58e77
leaq -0x30(%rbp), %r10
leaq -0x14(%rbp), %r11
leaq -0x18(%rbp), %rbx
leaq -0x1c(%rbp), %r14
leaq 0x2af1d0(%rip), %rdi    # 0x33b830
leaq 0x970fe(%rip), %rsi     # 0x123765
leaq -0x2c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x24(%rbp), %r8
leaq -0x20(%rbp), %r9
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
callq 0x9360
addq $0x20, %rsp
cmpl $0x8, %eax
jne 0x8c77b
movl $0xff, %eax
movl $0xff, %ecx
subl -0x2c(%rbp), %ecx
cvtsi2sd %ecx, %xmm1
movsd 0x91fe5(%rip), %xmm0    # 0x11e690
divsd %xmm0, %xmm1
movsd 0x7ca81(%rip), %xmm2    # 0x109138
mulsd %xmm2, %xmm1
leaq 0x281606(%rip), %rcx    # 0x30dcc8
movsd %xmm1, (%rcx)
xorps %xmm1, %xmm1
cvtsi2sdl -0x28(%rbp), %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
leaq 0x2815f3(%rip), %rcx    # 0x30dcd0
movsd %xmm1, (%rcx)
cvtsi2sdl -0x24(%rbp), %xmm3
leaq 0x2815eb(%rip), %rcx    # 0x30dcd8
movsd %xmm3, (%rcx)
xorps %xmm3, %xmm3
cvtsi2sdl -0x20(%rbp), %xmm3
divsd %xmm0, %xmm3
mulsd %xmm2, %xmm3
leaq 0x2815d8(%rip), %rcx    # 0x30dce0
movsd %xmm3, (%rcx)
xorps %xmm3, %xmm3
cvtsi2sdl -0x1c(%rbp), %xmm3
divsd %xmm0, %xmm3
movl $0xff, %ecx
subl -0x18(%rbp), %ecx
mulsd %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
leaq 0x2815b6(%rip), %rcx    # 0x30dce8
movsd %xmm3, (%rcx)
divsd %xmm0, %xmm2
movsd 0x7f1fe(%rip), %xmm3    # 0x10b940
mulsd %xmm3, %xmm2
leaq 0x2815a3(%rip), %rcx    # 0x30dcf0
movsd %xmm2, (%rcx)
subl -0x14(%rbp), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd %xmm0, %xmm2
mulsd %xmm3, %xmm2
leaq 0x28158e(%rip), %rax    # 0x30dcf8
movsd %xmm2, (%rax)
leaq 0x28158b(%rip), %rax    # 0x30dd00
movsd %xmm1, (%rax)
jmp 0x8c780
callq 0x8b1d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_lpfrs_id()
void parse_lpfrs_id()
{
   log_packet_id("id info");

   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   nmea_msg[14] = 0;
   strcpy(lpfrs_id, nmea_msg);

   nmea_msg[36] = 0;
   strcpy(lpfrs_fw, &nmea_msg[16]);

   nmea_msg[57] = 0;
   strcpy(lpfrs_ck, &nmea_msg[37]);

   if(lpfrs_id[0] && lpfrs_fw[0] && lpfrs_ck[0]) have_info |= (ALL_ID_INFO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x96fe8(%rip), %rdi     # 0x123786
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8c7bf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b1d0
leaq 0x2af06a(%rip), %r15    # 0x33b830
xorl %r13d, %r13d
movb %r13b, 0xe(%r15)
leaq 0x28145c(%rip), %r12    # 0x30dc30
movq %r12, %rdi
movq %r15, %rsi
callq 0x9340
movb %r13b, 0x24(%r15)
leaq 0x10(%r15), %rsi
leaq 0x281472(%rip), %rbx    # 0x30dc60
movq %rbx, %rdi
callq 0x9340
movb %r13b, 0x39(%r15)
addq $0x25, %r15
leaq 0x28148b(%rip), %r14    # 0x30dc90
movq %r14, %rdi
movq %r15, %rsi
callq 0x9340
cmpb %r13b, (%r12)
je 0x8c82b
cmpb $0x0, (%rbx)
je 0x8c82b
cmpb $0x0, (%r14)
je 0x8c82b
leaq 0x28114c(%rip), %rax    # 0x30d974
orb $0xf, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_lpfrs_c_read()
void parse_lpfrs_c_read()
{
   log_packet_id("coarse tune word");

   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   lpfrs_c_rval = atohex(nmea_msg);
   lpfrs_c_rval &= 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x97121(%rip), %rdi     # 0x123966
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8c859
popq %rbp
jmp 0x8b1d0
leaq 0x2aefd0(%rip), %rdi    # 0x33b830
callq 0x98c6
movzbl %al, %eax
leaq 0x281449(%rip), %rcx    # 0x30dcb8
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_lpfrs_f_read()
void parse_lpfrs_f_read()
{
int i, j;

   log_packet_id("fine tune word");

   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }

   lpfrs_f_rval = atohex(nmea_msg);
   lpfrs_f_rval &= 0xFF;

   if(lpfrs_c_rval & 0x80) i = lpfrs_c_rval - 256;
   else                    i = lpfrs_c_rval;

   if(lpfrs_f_rval & 0x80) j = lpfrs_f_rval - 256;
   else                    j = lpfrs_f_rval;

   lpfrs_freq = 1.0E-9 * (double) i;
   lpfrs_freq += (1.0E-11 * (double) j);

   osc_offset = lpfrs_freq * 1.0E9;
   have_osc_offset = 78;
//sprintf(debug_text, "fread i:%d j:%d freq:%g ofs:%g", i,j,lpfrs_freq,osc_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x970f9(%rip), %rdi     # 0x123977
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8c892
popq %rbp
jmp 0x8b1d0
leaq 0x2aef97(%rip), %rdi    # 0x33b830
callq 0x98c6
movzbl %al, %eax
leaq 0x281410(%rip), %rcx    # 0x30dcb8
movl (%rcx), %ecx
movl $0xffffff00, %edx       # imm = 0xFFFFFF00
leal (%rcx,%rdx), %esi
testb %cl, %cl
cmovnsl %ecx, %esi
movsbl %al, %ecx
andl %edx, %ecx
leaq 0x2813f9(%rip), %rdx    # 0x30dcbc
orl %eax, %ecx
cvtsi2sd %esi, %xmm0
mulsd 0x9191f(%rip), %xmm0    # 0x11e1f0
cvtsi2sd %ecx, %xmm1
movl %eax, (%rdx)
mulsd 0x91dd1(%rip), %xmm1    # 0x11e6b0
addsd %xmm0, %xmm1
leaq 0x2813d6(%rip), %rax    # 0x30dcc0
movsd %xmm1, (%rax)
mulsd 0x7c732(%rip), %xmm1    # 0x109028
leaq 0x27fec3(%rip), %rax    # 0x30c7c0
movsd %xmm1, (%rax)
leaq 0x28092c(%rip), %rax    # 0x30d234
movl $0x4e, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_lpfrs_freq(double)
void set_lpfrs_freq(double freq)
{
int high, low;
double val;

   if(read_only) return;

   if(freq > 1.27E-7) freq = 1.27E-7;
   if(freq < -1.28E-7) freq = -1.28E-7;

   high = (int) (freq / 1.0E-9);
   val = freq - ((double) high * 1.0E-9);
   low = (int) (val / 1.0E-11);

   sprintf(out, "C%02X", high & 0xFF);
   queue_lpfrs_cmd(out, LPFRS_C_WRITE_MSG);
   sprintf(out, "F%02X", low & 0xFF);
   queue_lpfrs_cmd(out, LPFRS_F_WRITE_MSG);

   BEEP(505);  // signal EEPROM write
//sprintf(debug_text2, "set freq %g:  val:%g  high:%d low:%d", freq,val,high,low);
}

// Assembly:
leaq 0x2aa6c1(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8c95f
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd 0x7f087(%rip), %xmm1    # 0x10b9f8
minsd %xmm0, %xmm1
movsd 0x7f073(%rip), %xmm0    # 0x10b9f0
maxsd %xmm1, %xmm0
movsd 0x91867(%rip), %xmm1    # 0x11e1f0
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %edx
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
divsd 0x91d03(%rip), %xmm0    # 0x11e6b0
cvttsd2si %xmm0, %ebx
movl $0xff, %r15d
andl %r15d, %edx
leaq 0x2af85f(%rip), %r14    # 0x33c220
leaq 0x96fe0(%rip), %rsi     # 0x1239a8
movq %r14, %rdi
xorl %eax, %eax
callq 0x9060
movq %r14, %rdi
movl $0x389, %esi            # imm = 0x389
callq 0x5ee52
andl %r15d, %ebx
leaq 0x96fc5(%rip), %rsi     # 0x1239ae
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x9060
movq %r14, %rdi
movl $0x38a, %esi            # imm = 0x38A
callq 0x5ee52
movl $0x1f9, %edi            # imm = 0x1F9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_id()
void parse_prs_id()
{
char *s;
   
   log_packet_id("");
   log_packet_id("id info");
   prs_fw[0] = 0;
   prs_sn[0] = 0;

   s = strstr(nmea_msg, "_SN_");
   if(s == 0) return;

   *s = 0;
   strcpy(prs_fw, nmea_msg);

   if(s[1]) strcpy(prs_sn, s+1);
   if(all_polled) have_info |= ALL_ID_INFO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xa4da3(%rip), %rdi     # 0x1319a6
callq 0x58e77
leaq 0x96b77(%rip), %rdi     # 0x123786
callq 0x58e77
leaq 0x280e95(%rip), %rax    # 0x30dab0
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x280eba(%rip), %rax    # 0x30dae0
movb %cl, (%rax)
leaq 0x2aec01(%rip), %rdi    # 0x33b830
leaq 0x96e4d(%rip), %rsi     # 0x123a83
callq 0x9090
testq %rax, %rax
je 0x8cc84
movq %rax, %rbx
movb $0x0, (%rax)
leaq 0x280e63(%rip), %rdi    # 0x30dab0
leaq 0x2aebdc(%rip), %rsi    # 0x33b830
callq 0x9340
cmpb $0x0, 0x1(%rbx)
je 0x8cc71
incq %rbx
leaq 0x280e77(%rip), %rdi    # 0x30dae0
movq %rbx, %rsi
callq 0x9340
cmpl $0x0, 0x2df150(%rip)    # 0x36bdc8
je 0x8cc84
leaq 0x280cf3(%rip), %rax    # 0x30d974
orb $0xf, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_st()
void parse_prs_st()
{
int i;

   // status
   log_packet_id("status");

   for(i=0; i<6; i++) {
      if(get_msg_field()) {
         prs_st[i] = atoi(msg_field);
         have_prs_st |= (1 << i);

         if(prs_st[0] & 0x0F) critical_alarms |= CRIT_PWR;
         else                 critical_alarms &= (~CRIT_PWR);

         if(prs_st[3] & 0x0C) critical_alarms |= CRIT_OCXO;
         else                 critical_alarms &= (~CRIT_OCXO);

         if(prs_st[5] & 0x06) critical_alarms |= CRIT_FPGA;  // bad interrupt or watchdog
         else                 critical_alarms &= (~CRIT_FPGA);
//       have_critical_alarms = 1;

         if(prs_st[5] & 0x18) minor_alarms |= MINOR_EEPROM;
         else                 minor_alarms &= (~MINOR_EEPROM);
         have_eeprom = 1;
      }
      else ++bad_prs_val;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x98d9d(%rip), %rdi     # 0x125a3d
callq 0x58e77
xorl %ebx, %ebx
leaq 0x18de42(%rip), %r15    # 0x21aaf0
leaq 0x28051b(%rip), %r13    # 0x30d1d0
leaq 0x28051c(%rip), %r14    # 0x30d1d8
leaq 0x2805e9(%rip), %r12    # 0x30d2ac
callq 0x811da
testl %eax, %eax
je 0x8cd45
leaq 0x2aed6d(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl $0x1, %edx
movl %ebx, %ecx
shll %cl, %edx
movl %eax, (%r15,%rbx,4)
leaq 0x18dd9c(%rip), %rax    # 0x21aa88
orl %edx, (%rax)
xorl %eax, %eax
testb $0xf, (%r15)
setne %al
movl (%r13), %ecx
andl $-0x1d, %ecx
leal (%rcx,%rax,4), %eax
xorl %ecx, %ecx
testb $0xc, 0xc(%r15)
setne %cl
shll $0x4, %ecx
orl %eax, %ecx
movl 0x14(%r15), %eax
xorl %edx, %edx
testb $0x6, %al
setne %dl
leal (%rcx,%rdx,8), %ecx
movl %ecx, (%r13)
xorl %ecx, %ecx
testb $0x18, %al
setne %cl
movl (%r14), %eax
movl $0xfffffbff, %edx       # imm = 0xFFFFFBFF
andl %edx, %eax
shll $0xa, %ecx
orl %eax, %ecx
movl %ecx, (%r14)
movl $0x1, (%r12)
jmp 0x8cd4b
incl 0x2dfee9(%rip)          # 0x36cc34
incq %rbx
cmpq $0x6, %rbx
jne 0x8ccc3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_lm()
void parse_prs_lm()
{
   // lock mode
   log_packet_id("lock mode");

   if(get_msg_field()) {
      prs_lm = atoi(msg_field);
      have_prs_lm = 1;
      if(prs_lm & 0x0C) pps_enabled = 0;
      else pps_enabled = 1;
      have_pps_enable = 1;

      if(prs_lm == 3) pps_polarity = 1;
      else            pps_polarity = 0;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96d16(%rip), %rdi     # 0x123a88
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8cdcc
leaq 0x2aecb9(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18dd75(%rip), %rcx    # 0x21ab08
movl %eax, (%rcx)
leaq 0x18dcf0(%rip), %rcx    # 0x21aa8c
testb $0xc, %al
leaq 0x280f7b(%rip), %rdx    # 0x30dd20
sete (%rdx)
movl $0x1, %edx
movl %edx, (%rcx)
leaq 0x280526(%rip), %rcx    # 0x30d2dc
movl %edx, (%rcx)
cmpl $0x3, %eax
jne 0x8cdd4
leaq 0x280f54(%rip), %rax    # 0x30dd18
movl $0x1, (%rax)
jmp 0x8cde1
incl 0x2dfe62(%rip)          # 0x36cc34
jmp 0x8cde1
leaq 0x280f3d(%rip), %rax    # 0x30dd18
movl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_lo()
void parse_prs_lo()
{
   // lock loop enable
   log_packet_id("loop lock enable");

   if(get_msg_field()) {
      prs_lo = atoi(msg_field);

      if     (prs_lo == 0) discipline_mode = DIS_MODE_DISABLED; // DIS_MODE_MANUAL_HOLD;
      else if(prs_lo == 1) discipline_mode = DIS_MODE_NORMAL;
      else                 discipline_mode = DIS_MODE_UNKNOWN;
      have_prs_lo = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96ca4(%rip), %rdi     # 0x123a92
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8ce3e
leaq 0x2aec3d(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18dcfd(%rip), %rcx    # 0x21ab0c
movl %eax, (%rcx)
cmpl $0x1, %eax
setne %cl
negb %cl
testl %eax, %eax
movzbl %cl, %eax
movl $0x6, %ecx
cmovnel %eax, %ecx
leaq 0x28066a(%rip), %rax    # 0x30d497
movb %cl, (%rax)
leaq 0x18dc5a(%rip), %rax    # 0x21aa90
movl $0x1, (%rax)
jmp 0x8ce44
incl 0x2dfdf0(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ep()
void parse_prs_ep()
{
   // enable power
   log_packet_id("enable power");

   if(get_msg_field()) {
      prs_ep = atoi(msg_field);
      have_prs_ep = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96c52(%rip), %rdi     # 0x123aa3
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8ce83
leaq 0x2aebda(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18dd06(%rip), %rcx    # 0x21ab78
movl %eax, (%rcx)
leaq 0x18dc65(%rip), %rax    # 0x21aae0
movl $0x1, (%rax)
jmp 0x8ce89
incl 0x2dfdab(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_fc()
void parse_prs_fc()
{
double val;

   // frequecny control 
   log_packet_id("frequency control");

   if(get_msg_field()) {
      prs_fc1 = atoi(msg_field);
      have_prs_fc |= 0x01;
   }
   else ++bad_prs_val;

   if(get_msg_field()) {
      prs_fc2 = atoi(msg_field);
      have_prs_fc |= 0x02;
   }
   else ++bad_prs_val;

   val = (double) (prs_fc1 - 2048) * 1000.0;
   val += (double) (prs_fc2 - 2048); // freq DAC control word
   val *= 1.5;
   prs_fc_ppt = (val * 1.0E-12);
   val /= 1000.0;      // convert to ppt
   osc_offset = (val - prs_fc_ref);  // remove reference value to get current steering change
//sprintf(debug_text3, "fc:%d %d -> %g %g   (%g .. %g)  %g", prs_fc1,prs_fc2, 
//val, osc_offset, plot[OSC].min_disp_val,plot[OSC].max_disp_val,(plot[OSC].max_disp_val-plot[OSC].min_disp_val)*1.0E6);
   have_osc_offset = 32;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96c1a(%rip), %rdi     # 0x123ab0
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8cec5
leaq 0x2aeb95(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18dc59(%rip), %rcx    # 0x21ab10
movl %eax, (%rcx)
leaq 0x18dbd4(%rip), %rax    # 0x21aa94
orb $0x1, (%rax)
jmp 0x8cecb
incl 0x2dfd69(%rip)          # 0x36cc34
callq 0x811da
testl %eax, %eax
je 0x8cef5
leaq 0x2aeb65(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18dc2d(%rip), %rcx    # 0x21ab14
movl %eax, (%rcx)
leaq 0x18dba4(%rip), %rax    # 0x21aa94
orb $0x2, (%rax)
jmp 0x8cefb
incl 0x2dfd39(%rip)          # 0x36cc34
leaq 0x18dc0e(%rip), %rax    # 0x21ab10
movl $0xfffff800, %ecx       # imm = 0xFFFFF800
movl (%rax), %eax
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x7c121(%rip), %xmm1    # 0x109038
leaq 0x18dbf6(%rip), %rax    # 0x21ab14
addl (%rax), %ecx
cvtsi2sd %ecx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm0, %xmm2
mulsd 0x7c184(%rip), %xmm2    # 0x1090b8
movsd 0x91214(%rip), %xmm0    # 0x11e150
mulsd %xmm2, %xmm0
leaq 0x18dd01(%rip), %rax    # 0x21ac48
movsd %xmm0, (%rax)
divsd %xmm1, %xmm2
subsd 0x2e4f41(%rip), %xmm2   # 0x371e98
leaq 0x27f862(%rip), %rax    # 0x30c7c0
movsd %xmm2, (%rax)
leaq 0x2802cb(%rip), %rax    # 0x30d234
movl $0x20, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_fc2()
void parse_prs_fc2()
{
int life;
double val;

   // frequency control eeprom settings
   log_packet_id("frequency control eeprom");

   if(get_msg_field()) {  // power cycles
      prs_pwr_cycles = atoi(msg_field);
      have_prs_fc2 |= 0x01;
   }
   else ++bad_prs_val;

   if(get_msg_field()) {
      prs_fc_writes = atoi(msg_field);
      have_prs_fc2 |= 0x02;

      life = prs_fc_writes;  // updated around twice a day (manual says daily)
      if(prs_fc_writes > prs_pwr_cycles) life -= prs_pwr_cycles;
      scpi_life = (life * 12);  // updated around twice a day (manual says daily)
      have_lifetime = 1;
   }
   else ++bad_prs_val;

   if(get_msg_field()) {
      prs_ee_fc1 = atoi(msg_field);
   }
   else ++bad_prs_val;

   if(get_msg_field()) {
      prs_ee_fc2 = atoi(msg_field);
   }
   else ++bad_prs_val;

   val = (double) (prs_ee_fc1 - 2048) * 1000.0;
   val += (double) (prs_ee_fc2 - 2048); // DAC reference setting
   val *= 1.5;
   prs_ee_fc_ppt = (val * 1.0E-12);
   val /= 1000.0;
   prs_fc_ref = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96b46(%rip), %rdi     # 0x123ac2
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8cfab
leaq 0x2aeaaf(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18db83(%rip), %rcx    # 0x21ab20
movl %eax, (%rcx)
leaq 0x18daf2(%rip), %rax    # 0x21aa98
orb $0x1, (%rax)
jmp 0x8cfb1
incl 0x2dfc83(%rip)          # 0x36cc34
callq 0x811da
testl %eax, %eax
je 0x8d009
leaq 0x2aea7f(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18dacb(%rip), %rcx    # 0x21aa98
orb $0x2, (%rcx)
leaq 0x18db49(%rip), %rcx    # 0x21ab20
movl (%rcx), %ecx
xorl %edx, %edx
cmpl %ecx, %eax
cmovgl %ecx, %edx
leaq 0x18db3d(%rip), %rcx    # 0x21ab24
movl %eax, (%rcx)
subl %edx, %eax
shll $0x2, %eax
leal (%rax,%rax,2), %eax
leaq 0x280464(%rip), %rcx    # 0x30d45c
movl %eax, (%rcx)
leaq 0x2802c7(%rip), %rax    # 0x30d2c8
movl $0x1, (%rax)
jmp 0x8d00f
incl 0x2dfc25(%rip)          # 0x36cc34
callq 0x811da
testl %eax, %eax
je 0x8d02f
leaq 0x2aea21(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18daed(%rip), %rcx    # 0x21ab18
movl %eax, (%rcx)
jmp 0x8d035
incl 0x2dfbff(%rip)          # 0x36cc34
callq 0x811da
testl %eax, %eax
je 0x8d055
leaq 0x2ae9fb(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18dacb(%rip), %rcx    # 0x21ab1c
movl %eax, (%rcx)
jmp 0x8d05b
incl 0x2dfbd9(%rip)          # 0x36cc34
leaq 0x18dab6(%rip), %rax    # 0x21ab18
movl $0xfffff800, %ecx       # imm = 0xFFFFF800
movl (%rax), %eax
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x7bfc1(%rip), %xmm1    # 0x109038
leaq 0x18da9e(%rip), %rax    # 0x21ab1c
addl (%rax), %ecx
mulsd %xmm1, %xmm0
cvtsi2sd %ecx, %xmm2
addsd %xmm0, %xmm2
mulsd 0x7c024(%rip), %xmm2    # 0x1090b8
movsd 0x910b4(%rip), %xmm0    # 0x11e150
mulsd %xmm2, %xmm0
leaq 0x18dba9(%rip), %rax    # 0x21ac50
movsd %xmm0, (%rax)
divsd %xmm1, %xmm2
movsd %xmm2, 0x2e4de1(%rip)   # 0x371e98
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ds()
void parse_prs_ds()
{
   // detected signals 
   log_packet_id("detected signals");

   if(get_msg_field()) {
      prs_ds1 = atoi(msg_field);
      have_prs_ds |= 0x01;
   }
   else ++bad_prs_val;

   if(get_msg_field()) {
      prs_ds2 = atoi(msg_field);
      have_prs_ds |= 0x02;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96a17(%rip), %rdi     # 0x123adb
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d0f3
leaq 0x2ae967(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18da43(%rip), %rcx    # 0x21ab28
movl %eax, (%rcx)
leaq 0x18d9ae(%rip), %rax    # 0x21aa9c
orb $0x1, (%rax)
jmp 0x8d0f9
incl 0x2dfb3b(%rip)          # 0x36cc34
callq 0x811da
testl %eax, %eax
je 0x8d123
leaq 0x2ae937(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18da17(%rip), %rcx    # 0x21ab2c
movl %eax, (%rcx)
leaq 0x18d97e(%rip), %rax    # 0x21aa9c
orb $0x2, (%rax)
jmp 0x8d129
incl 0x2dfb0b(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_sf()
void parse_prs_sf()
{
   // set frequency
   log_packet_id("set frequency");

   if(get_msg_field()) {
      prs_sf = atoi(msg_field);
      have_prs_sf = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x969b6(%rip), %rdi     # 0x123aec
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d168
leaq 0x2ae8f5(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d9d9(%rip), %rcx    # 0x21ab30
movl %eax, (%rcx)
leaq 0x18d940(%rip), %rax    # 0x21aaa0
movl $0x1, (%rax)
jmp 0x8d16e
incl 0x2dfac6(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ss()
void parse_prs_ss()
{
   // set slope
   log_packet_id("set slope");

   if(get_msg_field()) {
      prs_ss = atoi(msg_field);
      have_prs_ss = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9697f(%rip), %rdi     # 0x123afa
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d1ad
leaq 0x2ae8b0(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d998(%rip), %rcx    # 0x21ab34
movl %eax, (%rcx)
leaq 0x18d8ff(%rip), %rax    # 0x21aaa4
movl $0x1, (%rax)
jmp 0x8d1b3
incl 0x2dfa81(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ga()
void parse_prs_ga()
{
   // gain
   log_packet_id("gain");

   if(get_msg_field()) {
      prs_ga = atoi(msg_field);
      have_prs_ga = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x80702(%rip), %rdi     # 0x10d8c2
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d1f2
leaq 0x2ae86b(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d957(%rip), %rcx    # 0x21ab38
movl %eax, (%rcx)
leaq 0x18d8be(%rip), %rax    # 0x21aaa8
movl $0x1, (%rax)
jmp 0x8d1f8
incl 0x2dfa3c(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ph()
void parse_prs_ph()
{
   // phase
   log_packet_id("phase");

   if(get_msg_field()) {
      prs_ph = atoi(msg_field);
      have_prs_ph = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x826c7(%rip), %rdi     # 0x10f8cc
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d237
leaq 0x2ae826(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d916(%rip), %rcx    # 0x21ab3c
movl %eax, (%rcx)
leaq 0x18d87d(%rip), %rax    # 0x21aaac
movl $0x1, (%rax)
jmp 0x8d23d
incl 0x2df9f7(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_sp()
void parse_prs_sp()
{
int i;

   // set parameters
   log_packet_id("set parameters");

   for(i=0; i<3; i++) {
      if(get_msg_field()) {
         prs_sp[i] = atoi(msg_field);
         have_prs_sp |= (1 << i);
      }
      else ++bad_prs_val;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x968b3(%rip), %rdi     # 0x123b04
callq 0x58e77
xorl %ebx, %ebx
leaq 0x2ae7e1(%rip), %r14    # 0x33ba40
leaq 0x18d8da(%rip), %r15    # 0x21ab40
leaq 0x18d843(%rip), %r12    # 0x21aab0
callq 0x811da
testl %eax, %eax
je 0x8d291
movq %r14, %rdi
callq 0x95e0
movl $0x1, %edx
movl %ebx, %ecx
shll %cl, %edx
movl %eax, (%r15,%rbx,4)
orl %edx, (%r12)
jmp 0x8d297
incl 0x2df99d(%rip)          # 0x36cc34
incq %rbx
cmpq $0x3, %rbx
jne 0x8d26d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ms()
void parse_prs_ms()
{
   // magnetic switching
   log_packet_id("magnetic switching");

   if(get_msg_field()) {
      prs_ms = atoi(msg_field);
      have_prs_ms = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9685f(%rip), %rdi     # 0x123b13
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d2e6
leaq 0x2ae777(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d877(%rip), %rcx    # 0x21ab4c
movl %eax, (%rcx)
leaq 0x18d7d6(%rip), %rax    # 0x21aab4
movl $0x1, (%rax)
jmp 0x8d2ec
incl 0x2df948(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_mo()
void parse_prs_mo()
{
   // magnetic offset
   log_packet_id("magnetic offset");

   if(get_msg_field()) {
      prs_mo = atoi(msg_field);
      have_prs_mo = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9682d(%rip), %rdi     # 0x123b26
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d32b
leaq 0x2ae732(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d836(%rip), %rcx    # 0x21ab50
movl %eax, (%rcx)
leaq 0x18d795(%rip), %rax    # 0x21aab8
movl $0x1, (%rax)
jmp 0x8d331
incl 0x2df903(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_mr()
void parse_prs_mr()
{
   // magnetic read
   log_packet_id("magnetic read");

   if(get_msg_field()) {
      prs_mr = atoi(msg_field);
      have_prs_mr = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x967f8(%rip), %rdi     # 0x123b36
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d370
leaq 0x2ae6ed(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d7f5(%rip), %rcx    # 0x21ab54
movl %eax, (%rcx)
leaq 0x18d754(%rip), %rax    # 0x21aabc
movl $0x1, (%rax)
jmp 0x8d376
incl 0x2df8be(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_tt()
void parse_prs_tt()
{
   // time tag
   log_packet_id("time tag");

   if(get_msg_field()) {
      prs_tt = atoi(msg_field);
      have_prs_tt = 1;
      if(prs_tt >= 0) {
         if(prs_tt >= 500000000) pps_offset = (OFS_SIZE) (prs_tt - 1000000000);
         else                    pps_offset = (OFS_SIZE) prs_tt;
         have_pps_offset = 1;
      }
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x967c1(%rip), %rdi     # 0x123b44
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d3e1
leaq 0x2ae6a8(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d7b4(%rip), %rcx    # 0x21ab58
movl %eax, (%rcx)
leaq 0x18d713(%rip), %rcx    # 0x21aac0
movl $0x1, (%rcx)
testl %eax, %eax
js 0x8d3e7
cmpl $0x1dcd6500, %eax       # imm = 0x1DCD6500
jl 0x8d3c3
addl $0xc4653600, %eax       # imm = 0xC4653600
cvtsi2sd %eax, %xmm0
leaq 0x27f3ea(%rip), %rax    # 0x30c7b8
movsd %xmm0, (%rax)
leaq 0x27fe5f(%rip), %rax    # 0x30d238
movl $0x1, (%rax)
jmp 0x8d3e7
incl 0x2df84d(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ts()
void parse_prs_ts()
{
   // time slope
   log_packet_id("time slope");

   if(get_msg_field()) {
      prs_ts = atoi(msg_field);
      have_prs_ts = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96759(%rip), %rdi     # 0x123b4d
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d426
leaq 0x2ae637(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d747(%rip), %rcx    # 0x21ab5c
movl %eax, (%rcx)
leaq 0x18d6a6(%rip), %rax    # 0x21aac4
movl $0x1, (%rax)
jmp 0x8d42c
incl 0x2df808(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_to()
void parse_prs_to()
{
   // time offset
   log_packet_id("time offset");

   if(get_msg_field()) {
      prs_to = atoi(msg_field);
      have_prs_to = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9671f(%rip), %rdi     # 0x123b58
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d46b
leaq 0x2ae5f2(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d706(%rip), %rcx    # 0x21ab60
movl %eax, (%rcx)
leaq 0x18d665(%rip), %rax    # 0x21aac8
movl $0x1, (%rax)
jmp 0x8d471
incl 0x2df7c3(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ps()
void parse_prs_ps()
{
   // pulse slope
   log_packet_id("pulse slope");

   if(get_msg_field()) {
      prs_ps = atoi(msg_field);
      have_prs_ps = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x966e6(%rip), %rdi     # 0x123b64
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d4b0
leaq 0x2ae5ad(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d6c5(%rip), %rcx    # 0x21ab64
movl %eax, (%rcx)
leaq 0x18d624(%rip), %rax    # 0x21aacc
movl $0x1, (%rax)
jmp 0x8d4b6
incl 0x2df77e(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_pl()
void parse_prs_pl()
{
   // phase lock
   log_packet_id("phase lock");

   if(get_msg_field()) {
      prs_pl = atoi(msg_field);
      have_prs_pl = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x966ad(%rip), %rdi     # 0x123b70
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d4f5
leaq 0x2ae568(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d684(%rip), %rcx    # 0x21ab68
movl %eax, (%rcx)
leaq 0x18d5e3(%rip), %rax    # 0x21aad0
movl $0x1, (%rax)
jmp 0x8d4fb
incl 0x2df739(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_pt()
void parse_prs_pt()
{
   // phase lock time constant
   log_packet_id("PLL time constant");

   if(get_msg_field()) {
      prs_pt = atoi(msg_field);
      have_prs_pt = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96673(%rip), %rdi     # 0x123b7b
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d53a
leaq 0x2ae523(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d643(%rip), %rcx    # 0x21ab6c
movl %eax, (%rcx)
leaq 0x18d5a2(%rip), %rax    # 0x21aad4
movl $0x1, (%rax)
jmp 0x8d540
incl 0x2df6f4(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_pf()
void parse_prs_pf()
{
   // phase lock freq stability
   log_packet_id("PLL freq stability");

   if(get_msg_field()) {
      prs_pf = atoi(msg_field);
      have_prs_pf = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96640(%rip), %rdi     # 0x123b8d
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d57f
leaq 0x2ae4de(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d602(%rip), %rcx    # 0x21ab70
movl %eax, (%rcx)
leaq 0x18d561(%rip), %rax    # 0x21aad8
movl $0x1, (%rax)
jmp 0x8d585
incl 0x2df6af(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_pi()
void parse_prs_pi()
{
   // phase lock integrator
   log_packet_id("PLL integrator");

   if(get_msg_field()) {
      prs_pi = atoi(msg_field);
      have_prs_pi = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9660e(%rip), %rdi     # 0x123ba0
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d5c4
leaq 0x2ae499(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d5c1(%rip), %rcx    # 0x21ab74
movl %eax, (%rcx)
leaq 0x18d520(%rip), %rax    # 0x21aadc
movl $0x1, (%rax)
jmp 0x8d5ca
incl 0x2df66a(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_sd(int)
void parse_prs_sd(int i)
{
   // dac data
   log_packet_id("dac data");

   if(i < 0) return;
   if(i > 7) return;

   if(get_msg_field()) {
      prs_sd[i] = atoi(msg_field);
      have_prs_sd |= (1 << i);
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x965d4(%rip), %rdi     # 0x123baf
callq 0x58e77
cmpl $0x7, %ebx
ja 0x8d620
callq 0x811da
testl %eax, %eax
je 0x8d61a
leaq 0x2ae44b(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %ebx, %ecx
leaq 0x18d57d(%rip), %rdx    # 0x21ab80
movl %eax, (%rdx,%rcx,4)
movl $0x1, %eax
movl %ebx, %ecx
shll %cl, %eax
leaq 0x18d4ce(%rip), %rcx    # 0x21aae4
orl %eax, (%rcx)
jmp 0x8d620
incl 0x2df614(%rip)          # 0x36cc34
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_ad(int)
void parse_prs_ad(int i)
{
double val;

   // analog data
   log_packet_id("analog data");

   if(i < 0) return;
   if(i > 19) return;

   if(get_msg_field()) {
      if(!strchr(msg_field, '.')) ++bad_prs_val;

      val = atof(msg_field);
      if     (i == 1) val *= 10.0;    // scale readings to actual values
      else if(i == 2) val *= 10.0;
      else if(i == 3) val *= 10.0;
      else if(i == 4) val *= 10.0;
      else if(i == 9) val *= 4.0;
      else if(i == 10) val *= 100.0;
      else if(i == 16) val *= 4.0;
      else if(i == 17) val *= 4.0;
      else if(i == 18) val *= 4.0;

      prs_ad[i] = val;
      have_prs_ad |= (1 << i);

      if((i == 1) || (i == 2)) {  // average of power readings
         prs_ad_pwr = ((prs_ad[1]+prs_ad[2])/2.0);  
      }
      else if(i == 10) {  // case temperature
         temperature = (DATA_SIZE) prs_ad[i];
         have_temperature = 104;
      }
      else if((i == 11) || (i == 12) || (i == 13)) { // average of thermistor readings
         prs_ad_therm = ((prs_ad[11]+prs_ad[12]+prs_ad[13])/3.0);  
      }
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x96582(%rip), %rdi     # 0x123bb8
callq 0x58e77
cmpl $0x13, %ebx
ja 0x8d735
callq 0x811da
testl %eax, %eax
je 0x8d697
leaq 0x2ae3ec(%rip), %rdi    # 0x33ba40
movl $0x2e, %esi
callq 0x9100
testq %rax, %rax
jne 0x8d669
incl 0x2df5cb(%rip)          # 0x36cc34
leaq 0x2ae3d0(%rip), %rdi    # 0x33ba40
callq 0x9470
leal -0x1(%rbx), %eax
cmpl $0x11, %eax
ja 0x8d6aa
leaq 0x91ccc(%rip), %rcx     # 0x11f350
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
mulsd 0x7ba13(%rip), %xmm0    # 0x1090a8
jmp 0x8d6aa
incl 0x2df597(%rip)          # 0x36cc34
jmp 0x8d735
mulsd 0x7e2be(%rip), %xmm0    # 0x10b968
movl %ebx, %ecx
leaq 0x18d4ed(%rip), %rdx    # 0x21aba0
movsd %xmm0, (%rdx,%rcx,8)
movl $0x1, %esi
movl %ebx, %ecx
shll %cl, %esi
leaq 0x18d420(%rip), %rcx    # 0x21aae8
orl %esi, (%rcx)
cmpl $0x1, %eax
ja 0x8d6ee
movsd 0x8(%rdx), %xmm0
addsd 0x10(%rdx), %xmm0
mulsd 0x7b987(%rip), %xmm0    # 0x109068
leaq 0x18d570(%rip), %rax    # 0x21ac58
movsd %xmm0, (%rax)
jmp 0x8d735
cmpl $0xa, %ebx
jne 0x8d70d
leaq 0x27f31e(%rip), %rax    # 0x30ca18
movsd %xmm0, (%rax)
leaq 0x27fb47(%rip), %rax    # 0x30d24c
movl $0x68, (%rax)
jmp 0x8d735
addl $-0xb, %ebx
cmpl $0x2, %ebx
ja 0x8d735
movsd 0x58(%rdx), %xmm0
addsd 0x60(%rdx), %xmm0
addsd 0x68(%rdx), %xmm0
divsd 0x7e2dc(%rip), %xmm0    # 0x10ba08
leaq 0x18d52d(%rip), %rax    # 0x21ac60
jmp 0x8d6e8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
mulsd 0x7b91c(%rip), %xmm0    # 0x109060
jmp 0x8d6aa
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prs_vb()
void parse_prs_vb()
{
   // verbose mode
   log_packet_id("verbose mode");

   if(get_msg_field()) {
      prs_vb = atoi(msg_field);
      have_prs_vb = 1;
   }
   else ++bad_prs_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x96470(%rip), %rdi     # 0x123bc4
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8d786
leaq 0x2ae2d7(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x18d377(%rip), %rcx    # 0x21aaec
movl %eax, (%rcx)
leaq 0x18d306(%rip), %rax    # 0x21aa84
movl $0x1, (%rax)
jmp 0x8d78c
incl 0x2df4a8(%rip)          # 0x36cc34
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_prs_ep(int)
void set_prs_ep(int val)
{
   if(read_only) return;

   sprintf(out, "EP%d", val);
   queue_prs_cmd(out, PRS_EP_MSG);
   queue_prs_cmd("EP?", PRS_EP_MSG);
}

// Assembly:
leaq 0x2a9885(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8d79b
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2aea76(%rip), %rbx    # 0x33c220
leaq 0x96420(%rip), %rsi     # 0x123bd1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x210, %esi            # imm = 0x210
callq 0x5ee52
leaq 0x961f3(%rip), %rdi     # 0x1239c2
movl $0x210, %esi            # imm = 0x210
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_prs_mo(int)
void set_prs_mo(int val)
{
   if(read_only) return;

   sprintf(out, "MO%d", val);
   queue_prs_cmd(out, PRS_MO_MSG);
   queue_prs_cmd("MO?", PRS_MO_MSG);
}

// Assembly:
leaq 0x2a9834(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8d7ec
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2aea25(%rip), %rbx    # 0x33c220
leaq 0x963d4(%rip), %rsi     # 0x123bd6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x204, %esi            # imm = 0x204
callq 0x5ee52
leaq 0x961ba(%rip), %rdi     # 0x1239da
movl $0x204, %esi            # imm = 0x204
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_prs_ms(int)
void set_prs_ms(int val)
{
   if(read_only) return;

   sprintf(out, "MS%d", val);
   queue_prs_cmd(out, PRS_MS_MSG);
   queue_prs_cmd("MS?", PRS_MS_MSG);
}

// Assembly:
leaq 0x2a97e3(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8d83d
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2ae9d4(%rip), %rbx    # 0x33c220
leaq 0x96388(%rip), %rsi     # 0x123bdb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x203, %esi            # imm = 0x203
callq 0x5ee52
leaq 0x96165(%rip), %rdi     # 0x1239d6
movl $0x203, %esi            # imm = 0x203
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_prs_sf(int)
void set_prs_sf(int val)
{
   if(read_only) return;

   sprintf(out, "SF%d", val);
   queue_prs_cmd(out, PRS_SF_MSG);
   queue_prs_cmd("SF?", PRS_SF_MSG);
}

// Assembly:
leaq 0x2a9752(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8d8ce
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2ae943(%rip), %rbx    # 0x33c220
leaq 0x96310(%rip), %rsi     # 0x123bf4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x1fe, %esi            # imm = 0x1FE
callq 0x5ee52
leaq 0x960cc(%rip), %rdi     # 0x1239ce
movl $0x1fe, %esi            # imm = 0x1FE
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_prs_sp(int, int, int)
void set_prs_sp(int r, int n, int a)
{
   if(read_only) return;

   sprintf(out, "SP%d,%d,%d", r,n,a);
   queue_prs_cmd(out, PRS_SP_MSG);
   queue_prs_cmd("SP?", PRS_SP_MSG);
}

// Assembly:
leaq 0x2a9701(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8d91f
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %r8d
movl %esi, %ecx
movl %edi, %edx
leaq 0x2ae8ed(%rip), %rbx    # 0x33c220
leaq 0x962bf(%rip), %rsi     # 0x123bf9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x5ee52
leaq 0x97e74(%rip), %rdi     # 0x1257cc
movl $0x202, %esi            # imm = 0x202
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52