LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_gf(int)
void set_sro_gf(int secs)
{
   if(read_only) return;

   if(secs < 0) secs = 0;
   if(secs > 65535) secs = 65535;
   sprintf(out, "GF%05d", secs);
   queue_sro_cmd(out, SRO_GF_MSG);
   sro_eeprom();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2d75b8(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbec49
jmp 0xbec94
cmpl $0x0, -0x4(%rbp)
jge 0xbec56
movl $0x0, -0x4(%rbp)
cmpl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jle 0xbec66
movl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
movl -0x4(%rbp), %edx
leaq 0x2dc790(%rip), %rdi    # 0x39b400
leaq 0xc8004(%rip), %rsi     # 0x186c7b
movb $0x0, %al
callq 0x9060
leaq 0x2dc77b(%rip), %rdi    # 0x39b400
movl $0x332, %esi            # imm = 0x332
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_width(double)
void set_sro_width(double usecs)
{
int val;

   if(read_only) return;

   if(usecs < 0.0) usecs = 0.0 - usecs;
   usecs *= 1000.0;
   usecs += (SRO_TICK / 2.0);
   val = (int) (usecs / SRO_TICK);
   if(val > 7499999) val = 7499999;
   sprintf(out, "PW%07d", val);
   queue_sro_cmd(out, SRO_PW_MSG);
   sro_eeprom();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d7546(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbecbe
jmp 0xbed4f
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0xbecd5
xorps %xmm0, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xb0353(%rip), %xmm0    # 0x16f030
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xc4339(%rip), %xmm0    # 0x183028
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xb2a8a(%rip), %xmm1    # 0x171790
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x7270df, -0xc(%rbp)   # imm = 0x7270DF
jle 0xbed21
movl $0x7270df, -0xc(%rbp)   # imm = 0x7270DF
movl -0xc(%rbp), %edx
leaq 0x2dc6d5(%rip), %rdi    # 0x39b400
leaq 0xc7f50(%rip), %rsi     # 0x186c82
movb $0x0, %al
callq 0x9060
leaq 0x2dc6c0(%rip), %rdi    # 0x39b400
movl $0x328, %esi            # imm = 0x328
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_delay(double)
void set_sro_delay(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, "DE%07d", val);
   queue_sro_cmd(out, SRO_DE_MSG);
   sro_eeprom();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d7486(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbed7b
jmp 0xbedfa
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0xbed92
xorps %xmm0, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xc428e(%rip), %xmm0    # 0x183028
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xb29df(%rip), %xmm1    # 0x171790
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jle 0xbedcc
movl $0xff, -0xc(%rbp)
movl -0xc(%rbp), %edx
leaq 0x2dc62a(%rip), %rdi    # 0x39b400
leaq 0xc7eac(%rip), %rsi     # 0x186c89
movb $0x0, %al
callq 0x9060
leaq 0x2dc615(%rip), %rdi    # 0x39b400
movl $0x327, %esi            # imm = 0x327
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_raw(double)
void set_sro_raw(double nsecs)
{
int val;

   if(read_only) return;

   val = (int) (nsecs / SRO_TICK);
   if(val > 127) val = 127;
   if(val < -128) val = -128;
   if(val < 0) sprintf(out, "RA%04d", val);
   else        sprintf(out, "RA+%03d", val);
   queue_sro_cmd(out, SRO_RA_MSG);
   sro_eeprom();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d73e6(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbee1e
jmp 0xbee9e
movsd -0x8(%rbp), %xmm0
movsd 0xb2965(%rip), %xmm1    # 0x171790
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x7f, -0xc(%rbp)
jle 0xbee43
movl $0x7f, -0xc(%rbp)
cmpl $-0x80, -0xc(%rbp)
jge 0xbee50
movl $0xffffff80, -0xc(%rbp) # imm = 0xFFFFFF80
cmpl $0x0, -0xc(%rbp)
jge 0xbee70
movl -0xc(%rbp), %edx
leaq 0x2dc5a0(%rip), %rdi    # 0x39b400
leaq 0xc7e29(%rip), %rsi     # 0x186c90
movb $0x0, %al
callq 0x9060
jmp 0xbee88
movl -0xc(%rbp), %edx
leaq 0x2dc586(%rip), %rdi    # 0x39b400
leaq 0xc7e16(%rip), %rsi     # 0x186c97
movb $0x0, %al
callq 0x9060
leaq 0x2dc571(%rip), %rdi    # 0x39b400
movl $0x331, %esi            # imm = 0x331
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_co(double)
void set_sro_co(double nsecs)
{
int val;

   if(read_only) return;

   val = (int) (nsecs);
   if(val > 127) val = 127;
   if(val < -128) val = -128;
   if(val < 0) sprintf(out, "CO%04d", val);
   else        sprintf(out, "CO+%03d", val);
   queue_sro_cmd(out, SRO_CO_MSG);
   sro_eeprom();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d7336(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbeecb
jmp 0xbef3b
cvttsd2si -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x7f, -0xc(%rbp)
jle 0xbeee0
movl $0x7f, -0xc(%rbp)
cmpl $-0x80, -0xc(%rbp)
jge 0xbeeed
movl $0xffffff80, -0xc(%rbp) # imm = 0xFFFFFF80
cmpl $0x0, -0xc(%rbp)
jge 0xbef0d
movl -0xc(%rbp), %edx
leaq 0x2dc503(%rip), %rdi    # 0x39b400
leaq 0xc7d9b(%rip), %rsi     # 0x186c9f
movb $0x0, %al
callq 0x9060
jmp 0xbef25
movl -0xc(%rbp), %edx
leaq 0x2dc4e9(%rip), %rdi    # 0x39b400
leaq 0xc7d88(%rip), %rsi     # 0x186ca6
movb $0x0, %al
callq 0x9060
leaq 0x2dc4d4(%rip), %rdi    # 0x39b400
movl $0x32e, %esi            # imm = 0x32E
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_fc(double)
void set_sro_fc(double ppb)
{
int val;

   if(read_only) return;

   val = (int) ((ppb*1.0E-12) / SRO_DDS_STEP);
   if(val > 32767) val = 32767;
   if(val < -32768) val = -32768;
   if(val < 0) sprintf(out, "FC%06d", val);
   else        sprintf(out, "FC+%05d", val);
   queue_sro_cmd(out, SRO_FC_MSG);
   queue_sro_cmd("L05", SRO_L05_MSG); 
   queue_sro_cmd("L06", SRO_L06_MSG); 
   sro_eeprom();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d7296(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbef6e
jmp 0xbf01e
movsd 0xc3c82(%rip), %xmm0    # 0x182bf8
mulsd -0x8(%rbp), %xmm0
movsd 0xb01f5(%rip), %xmm1    # 0x16f178
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x7fff, -0xc(%rbp)     # imm = 0x7FFF
jle 0xbef9e
movl $0x7fff, -0xc(%rbp)     # imm = 0x7FFF
cmpl $0xffff8000, -0xc(%rbp) # imm = 0xFFFF8000
jge 0xbefae
movl $0xffff8000, -0xc(%rbp) # imm = 0xFFFF8000
cmpl $0x0, -0xc(%rbp)
jge 0xbefce
movl -0xc(%rbp), %edx
leaq 0x2dc442(%rip), %rdi    # 0x39b400
leaq 0xc7ce9(%rip), %rsi     # 0x186cae
movb $0x0, %al
callq 0x9060
jmp 0xbefe6
movl -0xc(%rbp), %edx
leaq 0x2dc428(%rip), %rdi    # 0x39b400
leaq 0xc7cd6(%rip), %rsi     # 0x186cb5
movb $0x0, %al
callq 0x9060
leaq 0x2dc413(%rip), %rdi    # 0x39b400
movl $0x329, %esi            # imm = 0x329
callq 0x82fd0
leaq 0xc59e3(%rip), %rdi     # 0x1849e1
movl $0x33e, %esi            # imm = 0x33E
callq 0x82fd0
leaq 0xc59d6(%rip), %rdi     # 0x1849e5
movl $0x33f, %esi            # imm = 0x33F
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d71b6(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbf04b
jmp 0xbf0ca
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0xbf062
xorps %xmm0, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xc3fbe(%rip), %xmm0    # 0x183028
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xb270f(%rip), %xmm1    # 0x171790
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x7270df, -0xc(%rbp)   # imm = 0x7270DF
jle 0xbf09c
movl $0x7270df, -0xc(%rbp)   # imm = 0x7270DF
movl -0xc(%rbp), %edx
leaq 0x2dc35a(%rip), %rdi    # 0x39b400
leaq 0xc7c10(%rip), %rsi     # 0x186cbd
movb $0x0, %al
callq 0x9060
leaq 0x2dc345(%rip), %rdi    # 0x39b400
movl $0x32c, %esi            # imm = 0x32C
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d7116(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbf0eb
jmp 0xbf16a
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0xbf102
xorps %xmm0, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xc3f1e(%rip), %xmm0    # 0x183028
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xb266f(%rip), %xmm1    # 0x171790
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jle 0xbf13c
movl $0xff, -0xc(%rbp)
movl -0xc(%rbp), %edx
leaq 0x2dc2ba(%rip), %rdi    # 0x39b400
leaq 0xc7b77(%rip), %rsi     # 0x186cc4
movb $0x0, %al
callq 0x9060
leaq 0x2dc2a5(%rip), %rdi    # 0x39b400
movl $0x32b, %esi            # imm = 0x32B
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
leaq 0x2d707f(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbf185
jmp 0xbf20e
leaq 0x2ad568(%rip), %rax    # 0x36c6f4
movl (%rax), %edx
leaq 0x2ad55b(%rip), %rax    # 0x36c6f0
movl (%rax), %ecx
leaq 0x2ad54e(%rip), %rax    # 0x36c6ec
movl (%rax), %r8d
leaq 0x2dc258(%rip), %rdi    # 0x39b400
leaq 0xc7b1c(%rip), %rsi     # 0x186ccb
movb $0x0, %al
callq 0x9060
leaq 0x2dc243(%rip), %rdi    # 0x39b400
movl $0x333, %esi            # imm = 0x333
callq 0x82fd0
leaq 0x2ad51a(%rip), %rax    # 0x36c6e8
movl (%rax), %edx
leaq 0x2ad50d(%rip), %rax    # 0x36c6e4
movl (%rax), %ecx
leaq 0x2ad500(%rip), %rax    # 0x36c6e0
movl (%rax), %r8d
leaq 0x2dc216(%rip), %rdi    # 0x39b400
leaq 0xc7aeb(%rip), %rsi     # 0x186cdc
movb $0x0, %al
callq 0x9060
leaq 0x2dc201(%rip), %rdi    # 0x39b400
movl $0x334, %esi            # imm = 0x334
callq 0x82fd0
callq 0xbeb90
popq %rbp
retq
// File: 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
subq $0x10, %rsp
leaq 0xc8d10(%rip), %rdi     # 0x1883ef
callq 0x7add0
movl $0x137, -0x4(%rbp)      # imm = 0x137
cmpl $0x201, -0x4(%rbp)      # imm = 0x201
jge 0xbf703
movslq -0x4(%rbp), %rcx
leaq 0x2db311(%rip), %rax    # 0x39aa10
movb $0x0, (%rax,%rcx)
movl 0x30b8eb(%rip), %edx    # 0x3caff4
leaq 0x2de5c0(%rip), %rdi    # 0x39dcd0
leaq 0xc8ce6(%rip), %rsi     # 0x1883fd
leaq 0x2db2f2(%rip), %rcx    # 0x39aa10
movb $0x0, %al
callq 0x9060
leaq 0x1b82f8(%rip), %rax    # 0x277a24
movl $0x21f, (%rax)          # imm = 0x21F
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d67a6(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbfa5e
jmp 0xbfae5
movsd -0x8(%rbp), %xmm0
movsd 0xb1cb5(%rip), %xmm1    # 0x171720
ucomisd %xmm1, %xmm0
jbe 0xbfa7e
movsd 0xb1ca7(%rip), %xmm0    # 0x171720
movsd %xmm0, -0x8(%rbp)
movsd 0xb1c92(%rip), %xmm0    # 0x171718
ucomisd -0x8(%rbp), %xmm0
jbe 0xbfa9a
movsd 0xb1c83(%rip), %xmm0    # 0x171718
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xaf699(%rip), %xmm1    # 0x16f140
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
cvttsd2si -0x10(%rbp), %edx
leaq 0x2db944(%rip), %rdi    # 0x39b400
leaq 0xc7253(%rip), %rsi     # 0x186d16
movb $0x0, %al
callq 0x9060
leaq 0x2db92f(%rip), %rdi    # 0x39b400
movl $0x3eb, %esi            # imm = 0x3EB
callq 0x82fd0
movl $0x1f9, %edi            # imm = 0x1F9
callq 0x9ec0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
xorl %edi, %edi
callq 0xae4a0
leaq 0x2daeca(%rip), %rax    # 0x39aa10
movb $0x0, (%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x2d78d8(%rip), %rcx    # 0x397432
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0xbfba6
callq 0x7a510
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %dl
movslq -0x8(%rbp), %rcx
leaq 0x2dae99(%rip), %rax    # 0x39aa10
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x2dae86(%rip), %rax    # 0x39aa10
movb $0x0, (%rax,%rcx)
cmpl $0x1f5, -0x8(%rbp)      # imm = 0x1F5
jl 0xbfb99
jmp 0xbfba6
jmp 0xbfb9b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbfb50
leaq 0x2db277(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
leaq 0x2d787a(%rip), %rax    # 0x397434
movw $0x0, (%rax)
leaq 0x2d786c(%rip), %rax    # 0x397432
movw $0x0, (%rax)
leaq 0x2d7864(%rip), %rax    # 0x397436
movw $0x0, (%rax)
leaq 0x2dae32(%rip), %rdi    # 0x39aa10
callq 0x9890
leaq 0x1dd986(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0xbfc15
leaq 0x1dd979(%rip), %rax    # 0x29d570
movq (%rax), %rdi
movl 0x30c1d0(%rip), %edx    # 0x3cbdd0
leaq 0xc70e6(%rip), %rsi     # 0x186ced
leaq 0x2dae02(%rip), %rcx    # 0x39aa10
movb $0x0, %al
callq 0x9550
movl 0x30c1b5(%rip), %eax    # 0x3cbdd0
movl %eax, 0x30c1bf(%rip)    # 0x3cbde0
callq 0xb2630
movl %eax, -0x8(%rbp)
callq 0x97ce0
movl $0x0, 0x30c1a8(%rip)    # 0x3cbde0
leaq 0x1dd961(%rip), %rax    # 0x29d5a0
cmpq $0x0, (%rax)
je 0xbfc63
leaq 0x1c2b94(%rip), %rax    # 0x2827e0
cmpq $0x0, (%rax)
je 0xbfc63
leaq 0x1c2b87(%rip), %rax    # 0x2827e0
movq (%rax), %rax
movl %eax, %edi
callq 0xb8b0
leaq 0x1de516(%rip), %rax    # 0x29e180
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
leaq 0xc6d02(%rip), %rdi     # 0x186b4d
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbfe64
callq 0xbe120
jmp 0xbfeff
leaq 0x2daba5(%rip), %rax    # 0x39aa10
movb $0x0, 0xe(%rax)
leaq 0x2acf9a(%rip), %rdi    # 0x36ce10
leaq 0x2dab93(%rip), %rsi    # 0x39aa10
callq 0x9350
leaq 0x2dab87(%rip), %rax    # 0x39aa10
movb $0x0, 0x24(%rax)
leaq 0x2dab7c(%rip), %rsi    # 0x39aa10
addq $0x10, %rsi
leaq 0x2acfa1(%rip), %rdi    # 0x36ce40
callq 0x9350
leaq 0x2dab65(%rip), %rax    # 0x39aa10
movb $0x0, 0x39(%rax)
leaq 0x2dab5a(%rip), %rsi    # 0x39aa10
addq $0x25, %rsi
leaq 0x2acfaf(%rip), %rdi    # 0x36ce70
callq 0x9350
leaq 0x2acf43(%rip), %rax    # 0x36ce10
cmpb $0x0, (%rax)
je 0xbfeff
leaq 0x2acf67(%rip), %rax    # 0x36ce40
cmpb $0x0, (%rax)
je 0xbfeff
leaq 0x2acf8b(%rip), %rax    # 0x36ce70
cmpb $0x0, (%rax)
je 0xbfeff
leaq 0x2acc63(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0xf, %ecx
leaq 0x2acc57(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc6e12(%rip), %rdi     # 0x186d2d
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbff31
callq 0xbe120
jmp 0xbff60
leaq 0x2daad8(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2acf52(%rip), %rax    # 0x36ce98
movl %ecx, (%rax)
leaq 0x2acf49(%rip), %rax    # 0x36ce98
movl (%rax), %ecx
andl $0xff, %ecx
leaq 0x2acf3a(%rip), %rax    # 0x36ce98
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0xc6dbf(%rip), %rdi     # 0x186d3e
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbff98
callq 0xbe120
jmp 0xc009d
leaq 0x2daa71(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2aceef(%rip), %rax    # 0x36ce9c
movl %ecx, (%rax)
leaq 0x2acee6(%rip), %rax    # 0x36ce9c
movl (%rax), %ecx
andl $0xff, %ecx
leaq 0x2aced7(%rip), %rax    # 0x36ce9c
movl %ecx, (%rax)
leaq 0x2aceca(%rip), %rax    # 0x36ce98
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xbffed
leaq 0x2aceb7(%rip), %rax    # 0x36ce98
movl (%rax), %eax
subl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
jmp 0xbfff9
leaq 0x2acea4(%rip), %rax    # 0x36ce98
movl (%rax), %eax
movl %eax, -0x4(%rbp)
leaq 0x2ace9c(%rip), %rax    # 0x36ce9c
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc001f
leaq 0x2ace89(%rip), %rax    # 0x36ce9c
movl (%rax), %eax
subl $0x100, %eax            # imm = 0x100
movl %eax, -0x8(%rbp)
jmp 0xc002b
leaq 0x2ace76(%rip), %rax    # 0x36ce9c
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0xaf130(%rip), %xmm0    # 0x16f168
mulsd %xmm1, %xmm0
leaq 0x2ace5d(%rip), %rax    # 0x36cea0
movsd %xmm0, (%rax)
cvtsi2sdl -0x8(%rbp), %xmm0
leaq 0x2ace4d(%rip), %rax    # 0x36cea0
movsd (%rax), %xmm1
movsd 0xc2fd1(%rip), %xmm2    # 0x183030
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
leaq 0x2ace32(%rip), %rax    # 0x36cea0
movsd %xmm0, (%rax)
movsd 0xaefae(%rip), %xmm0    # 0x16f028
leaq 0x2ace1f(%rip), %rax    # 0x36cea0
mulsd (%rax), %xmm0
leaq 0x2ab914(%rip), %rax    # 0x36b9a0
movsd %xmm0, (%rax)
leaq 0x2ac37d(%rip), %rax    # 0x36c414
movl $0x4e, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x2d60d6(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xc012e
jmp 0xc0238
movsd -0x8(%rbp), %xmm0
movsd 0xb15f5(%rip), %xmm1    # 0x171730
ucomisd %xmm1, %xmm0
jbe 0xc014e
movsd 0xb15e7(%rip), %xmm0    # 0x171730
movsd %xmm0, -0x8(%rbp)
movsd 0xb15d2(%rip), %xmm0    # 0x171728
ucomisd -0x8(%rbp), %xmm0
jbe 0xc016a
movsd 0xb15c3(%rip), %xmm0    # 0x171728
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xaeff1(%rip), %xmm1    # 0x16f168
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movsd -0x8(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xaefbd(%rip), %xmm2    # 0x16f168
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0xc2e6b(%rip), %xmm1    # 0x183030
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edx
andl $0xff, %edx
leaq 0x2db220(%rip), %rdi    # 0x39b400
leaq 0xc6b88(%rip), %rsi     # 0x186d6f
movb $0x0, %al
callq 0x9060
leaq 0x2db20b(%rip), %rdi    # 0x39b400
movl $0x389, %esi            # imm = 0x389
callq 0x82fd0
movl -0x10(%rbp), %edx
andl $0xff, %edx
leaq 0x2db1f1(%rip), %rdi    # 0x39b400
leaq 0xc6b5f(%rip), %rsi     # 0x186d75
movb $0x0, %al
callq 0x9060
leaq 0x2db1dc(%rip), %rdi    # 0x39b400
movl $0x38a, %esi            # imm = 0x38A
callq 0x82fd0
movl $0x1f9, %edi            # imm = 0x1F9
callq 0x9ec0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
leaq 0xd40a3(%rip), %rdi     # 0x194592
callq 0x7add0
leaq 0xc6652(%rip), %rdi     # 0x186b4d
callq 0x7add0
leaq 0x2ac789(%rip), %rax    # 0x36cc90
movb $0x0, (%rax)
leaq 0x2ac7af(%rip), %rax    # 0x36ccc0
movb $0x0, (%rax)
leaq 0x2da4f5(%rip), %rdi    # 0x39aa10
leaq 0xc6928(%rip), %rsi     # 0x186e4a
callq 0x9090
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc0534
jmp 0xc058a
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
leaq 0x2ac74e(%rip), %rdi    # 0x36cc90
leaq 0x2da4c7(%rip), %rsi    # 0x39aa10
callq 0x9350
movq -0x8(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0xc056c
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
leaq 0x2ac759(%rip), %rdi    # 0x36ccc0
callq 0x9350
cmpl $0x0, 0x30aa35(%rip)    # 0x3cafa8
je 0xc058a
leaq 0x2ac5d8(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0xf, %ecx
leaq 0x2ac5cc(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: 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 0xc6714(%rip), %rdi     # 0x186e4f
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc07d0
leaq 0x2da4cb(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b9585(%rip), %rax    # 0x279ce8
movl %ecx, (%rax)
leaq 0x1b9500(%rip), %rax    # 0x279c6c
movl $0x1, (%rax)
leaq 0x1b956f(%rip), %rax    # 0x279ce8
movl (%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0xc078f
leaq 0x2ac776(%rip), %rax    # 0x36cf00
movb $0x0, (%rax)
jmp 0xc0799
leaq 0x2ac76a(%rip), %rax    # 0x36cf00
movb $0x1, (%rax)
leaq 0x2abd1c(%rip), %rax    # 0x36c4bc
movl $0x1, (%rax)
leaq 0x1b953b(%rip), %rax    # 0x279ce8
cmpl $0x3, (%rax)
jne 0xc07c1
leaq 0x2ac73f(%rip), %rax    # 0x36cef8
movl $0x1, (%rax)
jmp 0xc07ce
leaq 0x2ac730(%rip), %rax    # 0x36cef8
movl $0x0, (%rax)
jmp 0xc07df
movl 0x30b62e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b625(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc665e(%rip), %rdi     # 0x186e59
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc086c
leaq 0x2da40f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b94cd(%rip), %rax    # 0x279cec
movl %ecx, (%rax)
leaq 0x1b94c4(%rip), %rax    # 0x279cec
cmpl $0x0, (%rax)
jne 0xc0839
leaq 0x2abe43(%rip), %rax    # 0x36c677
movb $0x6, (%rax)
jmp 0xc085d
leaq 0x1b94ac(%rip), %rax    # 0x279cec
cmpl $0x1, (%rax)
jne 0xc0851
leaq 0x2abe2b(%rip), %rax    # 0x36c677
movb $0x0, (%rax)
jmp 0xc085b
leaq 0x2abe1f(%rip), %rax    # 0x36c677
movb $-0x1, (%rax)
jmp 0xc085d
leaq 0x1b940c(%rip), %rax    # 0x279c70
movl $0x1, (%rax)
jmp 0xc087b
movl 0x30b592(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b589(%rip)    # 0x3cbe04
popq %rbp
retq
nopl (%rax)
// File: 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 0xc65df(%rip), %rdi     # 0x186e6a
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc08c0
leaq 0x2da37f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b94a9(%rip), %rax    # 0x279d58
movl %ecx, (%rax)
leaq 0x1b9408(%rip), %rax    # 0x279cc0
movl $0x1, (%rax)
jmp 0xc08cf
movl 0x30b53e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b535(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0xc6588(%rip), %rdi     # 0x186e77
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc092c
leaq 0x2da31b(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b93dd(%rip), %rax    # 0x279cf0
movl %ecx, (%rax)
leaq 0x1b9358(%rip), %rax    # 0x279c74
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x1b934c(%rip), %rax    # 0x279c74
movl %ecx, (%rax)
jmp 0xc093b
movl 0x30b4d2(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b4c9(%rip)    # 0x3cbe04
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0973
leaq 0x2da2d4(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b939a(%rip), %rax    # 0x279cf4
movl %ecx, (%rax)
leaq 0x1b9311(%rip), %rax    # 0x279c74
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x1b9305(%rip), %rax    # 0x279c74
movl %ecx, (%rax)
jmp 0xc0982
movl 0x30b48b(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b482(%rip)    # 0x3cbe04
leaq 0x1b9367(%rip), %rax    # 0x279cf0
movl (%rax), %eax
subl $0x800, %eax            # imm = 0x800
cvtsi2sd %eax, %xmm0
movsd 0xae694(%rip), %xmm1    # 0x16f030
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
leaq 0x1b9348(%rip), %rax    # 0x279cf4
movl (%rax), %eax
subl $0x800, %eax            # imm = 0x800
cvtsi2sd %eax, %xmm0
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xae70f(%rip), %xmm0    # 0x16f0d8
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xc221d(%rip), %xmm0    # 0x182bf8
mulsd -0x8(%rbp), %xmm0
leaq 0x1b9441(%rip), %rax    # 0x279e28
movsd %xmm0, (%rax)
movsd -0x8(%rbp), %xmm0
movsd 0xae638(%rip), %xmm1    # 0x16f030
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
subsd 0x31066a(%rip), %xmm0   # 0x3d1078
leaq 0x2aaf8b(%rip), %rax    # 0x36b9a0
movsd %xmm0, (%rax)
leaq 0x2ab9f4(%rip), %rax    # 0x36c414
movl $0x20, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 0xc6277(%rip), %rdi     # 0x186ea2
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0c68
leaq 0x2d9fdf(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b90b9(%rip), %rax    # 0x279d08
movl %ecx, (%rax)
leaq 0x1b9024(%rip), %rax    # 0x279c7c
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x1b9018(%rip), %rax    # 0x279c7c
movl %ecx, (%rax)
jmp 0xc0c77
movl 0x30b196(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b18d(%rip)    # 0x3cbe04
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0caf
leaq 0x2d9f98(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b9076(%rip), %rax    # 0x279d0c
movl %ecx, (%rax)
leaq 0x1b8fdd(%rip), %rax    # 0x279c7c
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x1b8fd1(%rip), %rax    # 0x279c7c
movl %ecx, (%rax)
jmp 0xc0cbe
movl 0x30b14f(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b146(%rip)    # 0x3cbe04
popq %rbp
retq
// File: 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 0xc61e8(%rip), %rdi     # 0x186eb3
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0d00
leaq 0x2d9f3f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b9021(%rip), %rax    # 0x279d10
movl %ecx, (%rax)
leaq 0x1b8f88(%rip), %rax    # 0x279c80
movl $0x1, (%rax)
jmp 0xc0d0f
movl 0x30b0fe(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b0f5(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc6196(%rip), %rdi     # 0x186ec1
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0d60
leaq 0x2d9edf(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8fc5(%rip), %rax    # 0x279d14
movl %ecx, (%rax)
leaq 0x1b8f2c(%rip), %rax    # 0x279c84
movl $0x1, (%rax)
jmp 0xc0d6f
movl 0x30b09e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b095(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xb14cf(%rip), %rdi     # 0x17225a
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0dc0
leaq 0x2d9e7f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8f69(%rip), %rax    # 0x279d18
movl %ecx, (%rax)
leaq 0x1b8ed0(%rip), %rax    # 0x279c88
movl $0x1, (%rax)
jmp 0xc0dcf
movl 0x30b03e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30b035(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xb34d2(%rip), %rdi     # 0x1742bd
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0e20
leaq 0x2d9e1f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8f0d(%rip), %rax    # 0x279d1c
movl %ecx, (%rax)
leaq 0x1b8e74(%rip), %rax    # 0x279c8c
movl $0x1, (%rax)
jmp 0xc0e2f
movl 0x30afde(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30afd5(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0xc607c(%rip), %rdi     # 0x186ecb
callq 0x7add0
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0xc0ec3
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0ea7
leaq 0x2d9dae(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %edx
movslq -0x4(%rbp), %rcx
leaq 0x1b8e9c(%rip), %rax    # 0x279d20
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
leaq 0x1b8df6(%rip), %rax    # 0x279c90
orl (%rax), %ecx
leaq 0x1b8ded(%rip), %rax    # 0x279c90
movl %ecx, (%rax)
jmp 0xc0eb6
movl 0x30af57(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30af4e(%rip)    # 0x3cbe04
jmp 0xc0eb8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xc0e5b
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 0xc5fff(%rip), %rdi     # 0x186eda
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0f10
leaq 0x2d9d2f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8e2d(%rip), %rax    # 0x279d2c
movl %ecx, (%rax)
leaq 0x1b8d8c(%rip), %rax    # 0x279c94
movl $0x1, (%rax)
jmp 0xc0f1f
movl 0x30aeee(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30aee5(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5fb2(%rip), %rdi     # 0x186eed
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0f70
leaq 0x2d9ccf(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8dd1(%rip), %rax    # 0x279d30
movl %ecx, (%rax)
leaq 0x1b8d30(%rip), %rax    # 0x279c98
movl $0x1, (%rax)
jmp 0xc0f7f
movl 0x30ae8e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30ae85(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5f62(%rip), %rdi     # 0x186efd
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc0fd0
leaq 0x2d9c6f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8d75(%rip), %rax    # 0x279d34
movl %ecx, (%rax)
leaq 0x1b8cd4(%rip), %rax    # 0x279c9c
movl $0x1, (%rax)
jmp 0xc0fdf
movl 0x30ae2e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30ae25(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5f10(%rip), %rdi     # 0x186f0b
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc1091
leaq 0x2d9c0b(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8d15(%rip), %rax    # 0x279d38
movl %ecx, (%rax)
leaq 0x1b8c74(%rip), %rax    # 0x279ca0
movl $0x1, (%rax)
leaq 0x1b8cff(%rip), %rax    # 0x279d38
cmpl $0x0, (%rax)
jl 0xc108f
leaq 0x1b8cf3(%rip), %rax    # 0x279d38
cmpl $0x1dcd6500, (%rax)     # imm = 0x1DCD6500
jl 0xc106c
leaq 0x1b8ce4(%rip), %rax    # 0x279d38
movl (%rax), %eax
subl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
cvtsi2sd %eax, %xmm0
leaq 0x2aa932(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
jmp 0xc1082
leaq 0x1b8cc5(%rip), %rax    # 0x279d38
cvtsi2sdl (%rax), %xmm0
leaq 0x2aa91a(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
leaq 0x2ab38f(%rip), %rax    # 0x36c418
movl $0x1, (%rax)
jmp 0xc10a0
movl 0x30ad6d(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30ad64(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5e59(%rip), %rdi     # 0x186f14
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc10f0
leaq 0x2d9b4f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8c5d(%rip), %rax    # 0x279d3c
movl %ecx, (%rax)
leaq 0x1b8bbc(%rip), %rax    # 0x279ca4
movl $0x1, (%rax)
jmp 0xc10ff
movl 0x30ad0e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30ad05(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5e04(%rip), %rdi     # 0x186f1f
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc1150
leaq 0x2d9aef(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8c01(%rip), %rax    # 0x279d40
movl %ecx, (%rax)
leaq 0x1b8b60(%rip), %rax    # 0x279ca8
movl $0x1, (%rax)
jmp 0xc115f
movl 0x30acae(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30aca5(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5db0(%rip), %rdi     # 0x186f2b
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc11b0
leaq 0x2d9a8f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8ba5(%rip), %rax    # 0x279d44
movl %ecx, (%rax)
leaq 0x1b8b04(%rip), %rax    # 0x279cac
movl $0x1, (%rax)
jmp 0xc11bf
movl 0x30ac4e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30ac45(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5d5c(%rip), %rdi     # 0x186f37
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc1210
leaq 0x2d9a2f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8b49(%rip), %rax    # 0x279d48
movl %ecx, (%rax)
leaq 0x1b8aa8(%rip), %rax    # 0x279cb0
movl $0x1, (%rax)
jmp 0xc121f
movl 0x30abee(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30abe5(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5d07(%rip), %rdi     # 0x186f42
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc1270
leaq 0x2d99cf(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8aed(%rip), %rax    # 0x279d4c
movl %ecx, (%rax)
leaq 0x1b8a4c(%rip), %rax    # 0x279cb4
movl $0x1, (%rax)
jmp 0xc127f
movl 0x30ab8e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30ab85(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5cb9(%rip), %rdi     # 0x186f54
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc12d0
leaq 0x2d996f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8a91(%rip), %rax    # 0x279d50
movl %ecx, (%rax)
leaq 0x1b89f0(%rip), %rax    # 0x279cb8
movl $0x1, (%rax)
jmp 0xc12df
movl 0x30ab2e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30ab25(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5c6c(%rip), %rdi     # 0x186f67
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc1330
leaq 0x2d990f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b8a35(%rip), %rax    # 0x279d54
movl %ecx, (%rax)
leaq 0x1b8994(%rip), %rax    # 0x279cbc
movl $0x1, (%rax)
jmp 0xc133f
movl 0x30aace(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30aac5(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xc5c14(%rip), %rdi     # 0x186f76
callq 0x7add0
cmpl $0x0, -0x4(%rbp)
jge 0xc136f
jmp 0xc13cc
cmpl $0x7, -0x4(%rbp)
jle 0xc1377
jmp 0xc13cc
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc13bd
leaq 0x2d9898(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %edx
movslq -0x4(%rbp), %rcx
leaq 0x1b89c6(%rip), %rax    # 0x279d60
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
leaq 0x1b8914(%rip), %rax    # 0x279cc4
orl (%rax), %ecx
leaq 0x1b890b(%rip), %rax    # 0x279cc4
movl %ecx, (%rax)
jmp 0xc13cc
movl 0x30aa41(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30aa38(%rip)    # 0x3cbe04
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc5910(%rip), %rdi     # 0x186f8b
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xc16b0
leaq 0x2d958f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1b862d(%rip), %rax    # 0x279ccc
movl %ecx, (%rax)
leaq 0x1b85bc(%rip), %rax    # 0x279c64
movl $0x1, (%rax)
jmp 0xc16bf
movl 0x30a74e(%rip), %eax    # 0x3cbe04
addl $0x1, %eax
movl %eax, 0x30a745(%rip)    # 0x3cbe04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2d4b18(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xc16e9
jmp 0xc1723
movl -0x4(%rbp), %edx
leaq 0x2d9d0d(%rip), %rdi    # 0x39b400
leaq 0xc589e(%rip), %rsi     # 0x186f98
movb $0x0, %al
callq 0x9060
leaq 0x2d9cf8(%rip), %rdi    # 0x39b400
movl $0x210, %esi            # imm = 0x210
callq 0x82fd0
leaq 0xc5670(%rip), %rdi     # 0x186d89
movl $0x210, %esi            # imm = 0x210
callq 0x82fd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2d4ab8(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xc1749
jmp 0xc1783
movl -0x4(%rbp), %edx
leaq 0x2d9cad(%rip), %rdi    # 0x39b400
leaq 0xc5843(%rip), %rsi     # 0x186f9d
movb $0x0, %al
callq 0x9060
leaq 0x2d9c98(%rip), %rdi    # 0x39b400
movl $0x204, %esi            # imm = 0x204
callq 0x82fd0
leaq 0xc5628(%rip), %rdi     # 0x186da1
movl $0x204, %esi            # imm = 0x204
callq 0x82fd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2d4a58(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xc17a9
jmp 0xc17e3
movl -0x4(%rbp), %edx
leaq 0x2d9c4d(%rip), %rdi    # 0x39b400
leaq 0xc57e8(%rip), %rsi     # 0x186fa2
movb $0x0, %al
callq 0x9060
leaq 0x2d9c38(%rip), %rdi    # 0x39b400
movl $0x203, %esi            # imm = 0x203
callq 0x82fd0
leaq 0xc55c4(%rip), %rdi     # 0x186d9d
movl $0x203, %esi            # imm = 0x203
callq 0x82fd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)