LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_scpi_delim(char)
int get_scpi_delim(char delim)
{
char c;
int i;

   msg_field[0] = 0;
   if(nmea_msg[msg_col] == 0) return 0;  // at end-of-message

   i = 0;
   while(1) {   // get next field from the nmea message
      c = nmea_msg[msg_col];
      if(c == 0) {  // reached end-of-message
         break;
      }
      if(c == delim) {  // reached end-of-field
         ++msg_col;
         break;
      }

      if(i < ((int)sizeof(msg_field)-2)) {
         msg_field[i++] = c;
         msg_field[i] = 0;
         ++msg_col;
      }
   }

   return msg_field[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
leaq 0x2c4e7f(%rip), %rax    # 0x39ac20
movb $0x0, (%rax)
leaq 0x2c5079(%rip), %rax    # 0x39ae24
movslq (%rax), %rcx
leaq 0x2c4c5b(%rip), %rax    # 0x39aa10
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xd5dca
movl $0x0, -0x4(%rbp)
jmp 0xd5e70
movl $0x0, -0xc(%rbp)
leaq 0x2c504c(%rip), %rax    # 0x39ae24
movslq (%rax), %rcx
leaq 0x2c4c2e(%rip), %rax    # 0x39aa10
movb (%rax,%rcx), %al
movb %al, -0x6(%rbp)
movsbl -0x6(%rbp), %eax
cmpl $0x0, %eax
jne 0xd5df3
jmp 0xd5e63
movsbl -0x6(%rbp), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0xd5e16
leaq 0x2c501e(%rip), %rax    # 0x39ae24
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2c5012(%rip), %rax    # 0x39ae24
movl %ecx, (%rax)
jmp 0xd5e63
cmpl $0x1ff, -0xc(%rbp)      # imm = 0x1FF
jge 0xd5e5e
movb -0x6(%rbp), %dl
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0x2c4de9(%rip), %rax    # 0x39ac20
movb %dl, (%rax,%rcx)
movslq -0xc(%rbp), %rcx
leaq 0x2c4ddb(%rip), %rax    # 0x39ac20
movb $0x0, (%rax,%rcx)
leaq 0x2c4fd4(%rip), %rax    # 0x39ae24
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2c4fc8(%rip), %rax    # 0x39ae24
movl %ecx, (%rax)
jmp 0xd5dd1
leaq 0x2c4db6(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_vis()
void parse_scpi_vis()
{
int prn;
int sat_count;

   log_packet_id("scpi vis");

   sat_count = 0;
   for(prn=0; prn<=MAX_PRN; prn++) {
      sat[prn].visible = 0;
   }

   msg_col = 0;
   while(get_msg_field()) {
      prn = atoi(msg_field);
      if((prn >= 1) && (prn <= MAX_PRN)) { 
         sat[prn].visible = (-1);
         ++sat_count;
         have_count = 40;
      }
   }

   config_sat_count(sat_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb1dca(%rip), %rdi     # 0x188219
callq 0x7add0
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
jg 0xd6495
movslq -0x4(%rbp), %rcx
leaq 0x1c7d1a(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movl $0x0, 0x21c(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd6462
leaq 0x2c4988(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd6501
leaq 0x2c476d(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jl 0xd64ff
cmpl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
jg 0xd64ff
movslq -0x4(%rbp), %rcx
leaq 0x1c7cbb(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movl $0xffffffff, 0x21c(%rax) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq 0x295fff(%rip), %rax    # 0x36c4f8
movl $0x28, (%rax)
jmp 0xd64a2
movl -0x8(%rbp), %edi
callq 0x82080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_track()
void parse_scpi_track()
{
int prn;

   log_packet_id("scpi track");

   for(prn=0; prn<=MAX_PRN; prn++) { 
      sat[prn].tracking = sat[prn].visible;
      if(sat[prn].visible) sat[prn].level_msg = 14;
      else                 sat[prn].level_msg = 0;
      have_snr |= rinex_gnss(prn);
   }

   msg_col = 0;
   while(get_msg_field()) {
      prn = atoi(msg_field);
      if((prn >= 1) && (prn <= MAX_PRN)) { 
         sat[prn].tracking = (1);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb1d03(%rip), %rdi     # 0x188222
callq 0x7add0
movl $0x0, -0x4(%rbp)
cmpl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
jg 0xd65f0
movslq -0x4(%rbp), %rcx
leaq 0x1c7c4d(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movl 0x21c(%rax), %ecx
movslq -0x4(%rbp), %rdx
leaq 0x1c7c32(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movl %ecx, 0x218(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x1c7c17(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
cmpl $0x0, 0x21c(%rax)
je 0xd65aa
movslq -0x4(%rbp), %rcx
leaq 0x1c7bf9(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movl $0xe, 0x1c(%rax)
jmp 0xd65c6
movslq -0x4(%rbp), %rcx
leaq 0x1c7bdb(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movl $0x0, 0x1c(%rax)
movl -0x4(%rbp), %edi
callq 0x12d280
movl %eax, %ecx
leaq 0x295f55(%rip), %rax    # 0x36c52c
orl (%rax), %ecx
leaq 0x295f4c(%rip), %rax    # 0x36c52c
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd652b
leaq 0x2c482d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd6646
leaq 0x2c4612(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jl 0xd6644
cmpl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
jg 0xd6644
movslq -0x4(%rbp), %rcx
leaq 0x1c7b60(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movl $0x1, 0x218(%rax)
jmp 0xd65fd
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_efc()
void parse_scpi_efc()
{
   log_packet_id("scpi efc");

   msg_col = 0;
   if(get_msg_field()) {
      dac_voltage = (float) atof(msg_field);
      if(rcvr_type == CS_RCVR) dac_voltage *= 100.0;
      have_dac = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb1bd2(%rip), %rdi     # 0x18822d
callq 0x7add0
leaq 0x2c47bd(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd66d1
leaq 0x2c45a2(%rip), %rdi    # 0x39ac20
callq 0x9480
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x29554e(%rip), %rax    # 0x36bbe0
movsd %xmm0, (%rax)
leaq 0x1a1413(%rip), %rax    # 0x277ab0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0xd66c4
movsd 0x989a2(%rip), %xmm0    # 0x16f050
leaq 0x29552b(%rip), %rax    # 0x36bbe0
mulsd (%rax), %xmm0
leaq 0x295520(%rip), %rax    # 0x36bbe0
movsd %xmm0, (%rax)
leaq 0x295e11(%rip), %rax    # 0x36c4dc
movl $0x1, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_efc()
void parse_uccm_efc()
{
u32 val;

//kkkkkkuuuuuu
   log_packet_id("uccm efc");

   msg_col = 0;
   if(strstr(nmea_msg, "TO GPS")) {  // recovering from manual mode
      discipline_mode = DIS_MODE_RECOVERY;  // recovery
   }
   else if(strstr(nmea_msg, "RANGE")) {  // out of range
   }
   else if(get_msg_field() > 2) {
      if(discipline_mode == DIS_MODE_RECOVERY) discipline_mode = DIS_MODE_NORMAL;
      val = atohex(&msg_field[2]);
      uccm_voltage = (float) val;
   }
// sprintf(debug_text, "uccm voltage:%f  msg:%s", uccm_voltage, nmea_msg); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb1b47(%rip), %rdi     # 0x188236
callq 0x7add0
leaq 0x2c4729(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
leaq 0x2c4308(%rip), %rdi    # 0x39aa10
leaq 0xb1b30(%rip), %rsi     # 0x18823f
callq 0x9090
cmpq $0x0, %rax
je 0xd6726
leaq 0x295f56(%rip), %rax    # 0x36c677
movb $0x4, (%rax)
jmp 0xd6792
leaq 0x2c42e3(%rip), %rdi    # 0x39aa10
leaq 0xb2274(%rip), %rsi     # 0x1889a8
callq 0x9090
cmpq $0x0, %rax
je 0xd6741
jmp 0xd6790
callq 0xb0bd0
cmpl $0x2, %eax
jle 0xd678e
leaq 0x295f25(%rip), %rax    # 0x36c677
movzbl (%rax), %eax
cmpl $0x4, %eax
jne 0xd6764
leaq 0x295f16(%rip), %rax    # 0x36c677
movb $0x0, (%rax)
leaq 0x2c44b5(%rip), %rdi    # 0x39ac20
addq $0x2, %rdi
callq 0x98d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cvtsi2ss %rax, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x29545e(%rip), %rax    # 0x36bbe8
movsd %xmm0, (%rax)
jmp 0xd6790
jmp 0xd6792
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_led()
void parse_uccm_led()
{
int i;

   log_packet_id("uccm led");

   if(scpi_type == UCCMP_TYPE) { 
      if     (strstr(nmea_msg, "0")) strcpy(uccm_led_msg, "Initializing   ");
      else if(strstr(nmea_msg, "1")) strcpy(uccm_led_msg, "Normal         ");
      else goto uccm_style;
   }
   else {
      uccm_style:
      nmea_msg[16] = 0;
      strcpy(uccm_led_msg, nmea_msg);
      for(i=strlen(uccm_led_msg); i<16; i++) uccm_led_msg[i] = ' ';
      uccm_led_msg[16] = 0;
      strupr(uccm_led_msg);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb1a97(%rip), %rdi     # 0x188246
callq 0x7add0
leaq 0x1a3a05(%rip), %rax    # 0x27a1c0
cmpl $0x50, (%rax)
jne 0xd6822
leaq 0x2c4249(%rip), %rdi    # 0x39aa10
leaq 0xc1fe4(%rip), %rsi     # 0x1987b2
callq 0x9090
cmpq $0x0, %rax
je 0xd67ee
leaq 0x295660(%rip), %rdi    # 0x36be40
leaq 0xb1a68(%rip), %rsi     # 0x18824f
callq 0x9350
jmp 0xd6820
leaq 0x2c421b(%rip), %rdi    # 0x39aa10
leaq 0xbfc29(%rip), %rsi     # 0x196425
callq 0x9090
cmpq $0x0, %rax
je 0xd681c
leaq 0x295632(%rip), %rdi    # 0x36be40
leaq 0xb1a4a(%rip), %rsi     # 0x18825f
callq 0x9350
jmp 0xd681e
jmp 0xd6824
jmp 0xd6820
jmp 0xd6888
jmp 0xd6824
leaq 0x2c41e5(%rip), %rax    # 0x39aa10
movb $0x0, 0x10(%rax)
leaq 0x29560a(%rip), %rdi    # 0x36be40
leaq 0x2c41d3(%rip), %rsi    # 0x39aa10
callq 0x9350
leaq 0x2955f7(%rip), %rdi    # 0x36be40
callq 0x9120
movl %eax, -0x4(%rbp)
cmpl $0x10, -0x4(%rbp)
jge 0xd6871
movslq -0x4(%rbp), %rcx
leaq 0x2955de(%rip), %rax    # 0x36be40
movb $0x20, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd6851
leaq 0x2955c8(%rip), %rax    # 0x36be40
movb $0x0, 0x10(%rax)
leaq 0x2955bd(%rip), %rdi    # 0x36be40
callq 0x9890
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_cable()
void parse_scpi_cable()
{
   log_packet_id("scpi cable");

   msg_col = 0;
   if(get_msg_field()) {
      cable_delay = atof(msg_field);
      if(cable_delay >= 1.0) {  // cable delay is probably in nanoseconds (early firmware?)
         cable_delay *= 1.0E-9;
         cable_nsecs = 1;
      }
      else cable_nsecs = 0;  // standard is in seconds

      have_cable_delay = 1;
      show_cable_delay();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb19d4(%rip), %rdi     # 0x18826f
callq 0x7add0
leaq 0x2c457d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd6933
leaq 0x2c4362(%rip), %rdi    # 0x39ac20
callq 0x9480
leaq 0x2966de(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
leaq 0x2966d3(%rip), %rax    # 0x36cfa8
movsd (%rax), %xmm0
movsd 0x98787(%rip), %xmm1    # 0x16f068
ucomisd %xmm1, %xmm0
jb 0xd6914
movsd 0x98879(%rip), %xmm0    # 0x16f168
leaq 0x2966b2(%rip), %rax    # 0x36cfa8
mulsd (%rax), %xmm0
leaq 0x2966a7(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
leaq 0x2966bc(%rip), %rax    # 0x36cfc8
movl $0x1, (%rax)
jmp 0xd6921
leaq 0x2966ad(%rip), %rax    # 0x36cfc8
movl $0x0, (%rax)
leaq 0x295b6c(%rip), %rax    # 0x36c494
movl $0x1, (%rax)
callq 0xa0f60
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_elev()
void parse_scpi_elev()
{
   log_packet_id("scpi elev");

   msg_col = 0;
   if(get_msg_field()) {
      el_mask = (float) atof(msg_field);
      have_el_mask = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb192f(%rip), %rdi     # 0x18827a
callq 0x7add0
leaq 0x2c44cd(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd698f
leaq 0x2c42b2(%rip), %rdi    # 0x39ac20
callq 0x9480
cvtsd2ss %xmm0, %xmm0
leaq 0x295916(%rip), %rax    # 0x36c294
movss %xmm0, (%rax)
leaq 0x295c53(%rip), %rax    # 0x36c5dc
movl $0x1, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_utc_ofs()
void parse_scpi_utc_ofs()
{
   log_packet_id("scpi utc ofs");

   msg_col = 0;
   if(!user_set_utc_ofs && get_msg_field()) {
      utc_offset = (int) atof(msg_field);
      check_utc_ofs(10);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb18d9(%rip), %rdi     # 0x188284
callq 0x7add0
leaq 0x2c446d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
leaq 0x295f50(%rip), %rax    # 0x36c914
cmpl $0x0, (%rax)
jne 0xd69f6
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd69f6
leaq 0x2c4246(%rip), %rdi    # 0x39ac20
callq 0x9480
cvttsd2si %xmm0, %ecx
leaq 0x295f1e(%rip), %rax    # 0x36c908
movl %ecx, (%rax)
movl $0xa, %edi
callq 0x7a270
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_tint()
void parse_scpi_tint()
{
   log_packet_id("scpi tint");

   msg_col = 0;
   if(get_msg_field()) {
      if(scpi_type == NORTEL_TYPE) pps_offset = (float) atof(msg_field)*1.0;
      else                         pps_offset = (float) atof(msg_field)*1.0E9;
      // doing adves of TINT handled in secondary_timing()
      have_pps_offset = 7;
      have_rcvr_pps = 7;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb0d76(%rip), %rdi     # 0x188361
callq 0x7add0
leaq 0x2c382d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7685
leaq 0x1a2bb2(%rip), %rax    # 0x27a1c0
cmpl $0x4e, (%rax)
jne 0xd7640
leaq 0x2c3606(%rip), %rdi    # 0x39ac20
callq 0x9480
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x97a39(%rip), %xmm1    # 0x16f068
mulsd %xmm1, %xmm0
leaq 0x29435e(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
jmp 0xd766b
leaq 0x2c35d9(%rip), %rdi    # 0x39ac20
callq 0x9480
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x979cc(%rip), %xmm1    # 0x16f028
mulsd %xmm1, %xmm0
leaq 0x294331(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
leaq 0x294da6(%rip), %rax    # 0x36c418
movl $0x7, (%rax)
leaq 0x294da5(%rip), %rax    # 0x36c424
movl $0x7, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_progress()
void parse_scpi_progress()
{
   log_packet_id("scpi progress");

   msg_col = 0;
   if(get_msg_field()) {
      survey_progress = (int) atof(msg_field);
      have_progress = 5;
      if(scpi_type == NORTEL_TYPE) {
         if(survey_progress != 100) minor_alarms |= MINOR_SURVEY;
         else                       minor_alarms &= (~MINOR_SURVEY);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb0cd0(%rip), %rdi     # 0x18836b
callq 0x7add0
leaq 0x2c377d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7725
leaq 0x2c3562(%rip), %rdi    # 0x39ac20
callq 0x9480
cvttsd2si %xmm0, %ecx
leaq 0x29599e(%rip), %rax    # 0x36d06c
movl %ecx, (%rax)
leaq 0x295999(%rip), %rax    # 0x36d070
movl $0x5, (%rax)
leaq 0x1a2adc(%rip), %rax    # 0x27a1c0
cmpl $0x4e, (%rax)
jne 0xd7723
leaq 0x29597c(%rip), %rax    # 0x36d06c
cmpl $0x64, (%rax)
je 0xd770c
leaq 0x294cbc(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x20, %ecx
leaq 0x294cb0(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd7721
leaq 0x294ca5(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $-0x21, %ecx
leaq 0x294c99(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd7723
jmp 0xd7725
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_survey()
void parse_scpi_survey()
{
   log_packet_id("scpi survey");

   msg_col = 0;
// !!! should restore com_timeout
   if(get_msg_field()) {
      strupr(msg_field);
      if(strstr(msg_field, "ONCE"))   minor_alarms |= MINOR_SURVEY;
      else if(strstr(msg_field, "1")) minor_alarms |= MINOR_SURVEY;
      else                            minor_alarms &= (~MINOR_SURVEY);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb0c3e(%rip), %rdi     # 0x188379
callq 0x7add0
leaq 0x2c36dd(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd77e0
leaq 0x2c34be(%rip), %rdi    # 0x39ac20
callq 0x9890
leaq 0x2c34b2(%rip), %rdi    # 0x39ac20
leaq 0xad4ed(%rip), %rsi     # 0x184c62
callq 0x9090
cmpq $0x0, %rax
je 0xd7797
leaq 0x294c31(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x20, %ecx
leaq 0x294c25(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd77de
leaq 0x2c3482(%rip), %rdi    # 0x39ac20
leaq 0xbec80(%rip), %rsi     # 0x196425
callq 0x9090
cmpq $0x0, %rax
je 0xd77c7
leaq 0x294c01(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x20, %ecx
leaq 0x294bf5(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd77dc
leaq 0x294bea(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $-0x21, %ecx
leaq 0x294bde(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd77de
jmp 0xd77e0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_holdover()
void parse_scpi_holdover()
{
int state;

   log_packet_id("scpi holdover");

   msg_col = 0;
   if(get_msg_field()) {
      holdover = (int) atof(msg_field);
   }

   if(get_msg_field()) {
      state = atoi(msg_field);
      if(state) {  // in holdover mode
         discipline_mode = DIS_MODE_MANUAL_HOLD;
         if(!have_scpi_hold) user_holdover = 1;
if(scpi_type != UCCMP_TYPE) {  // kkkkkk
   rcvr_mode = RCVR_MODE_PROP;
   have_rcvr_mode = 10;
}
      }
      else {   // not in holdover
         discipline_mode = DIS_MODE_NORMAL;
         if(!have_scpi_hold) user_holdover = 0;
if(scpi_type != UCCMP_TYPE) {  // kkkkkk
   rcvr_mode = RCVR_MODE_HOLD;
   have_rcvr_mode = 10;
}
      }
      have_scpi_hold = 1;
   }
// !!! should restore com_timeout
if(debug_file) fprintf(debug_file, "### holdover:%d  dmode:%d  user:%d\n", holdover, discipline_mode, user_holdover);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb0b86(%rip), %rdi     # 0x188385
callq 0x7add0
leaq 0x2c3619(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7834
leaq 0x2c33fe(%rip), %rdi    # 0x39ac20
callq 0x9480
cvttsd2si %xmm0, %ecx
leaq 0x294e06(%rip), %rax    # 0x36c638
movl %ecx, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd78e8
leaq 0x2c33d7(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xd7899
leaq 0x294e19(%rip), %rax    # 0x36c677
movb $0x3, (%rax)
leaq 0x294dd8(%rip), %rax    # 0x36c640
cmpl $0x0, (%rax)
jne 0xd7877
leaq 0x294dc0(%rip), %rax    # 0x36c634
movb $0x1, (%rax)
leaq 0x1a2942(%rip), %rax    # 0x27a1c0
cmpl $0x50, (%rax)
je 0xd7897
leaq 0x294a26(%rip), %rax    # 0x36c2b0
movb $0x8, (%rax)
leaq 0x294d59(%rip), %rax    # 0x36c5ed
movb $0xa, (%rax)
jmp 0xd78db
leaq 0x294dd7(%rip), %rax    # 0x36c677
movb $0x0, (%rax)
leaq 0x294d96(%rip), %rax    # 0x36c640
cmpl $0x0, (%rax)
jne 0xd78b9
leaq 0x294d7e(%rip), %rax    # 0x36c634
movb $0x0, (%rax)
leaq 0x1a2900(%rip), %rax    # 0x27a1c0
cmpl $0x50, (%rax)
je 0xd78d9
leaq 0x2949e4(%rip), %rax    # 0x36c2b0
movb $0x7, (%rax)
leaq 0x294d17(%rip), %rax    # 0x36c5ed
movb $0xa, (%rax)
jmp 0xd78db
leaq 0x294d5e(%rip), %rax    # 0x36c640
movl $0x1, (%rax)
leaq 0x1c5c81(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0xd792b
leaq 0x1c5c74(%rip), %rax    # 0x29d570
movq (%rax), %rdi
leaq 0x294d32(%rip), %rax    # 0x36c638
movl (%rax), %edx
leaq 0x294d68(%rip), %rax    # 0x36c677
movzbl (%rax), %ecx
leaq 0x294d1b(%rip), %rax    # 0x36c634
movzbl (%rax), %r8d
leaq 0xb0a6f(%rip), %rsi     # 0x188393
movb $0x0, %al
callq 0x9550
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_utc()
void parse_scpi_utc()
{
int state;

   log_packet_id("scpi utc");

   msg_col = 0;
   if(get_msg_field()) {
      state = (int) atof(msg_field);
      if(state == 0) {  // GPS time
         time_flags &= (~TFLAGS_UTC);
         timing_mode = TMODE_GPS;
         have_timing_mode = 1;
      }
      else {  // utc time
         time_flags |= (TFLAGS_UTC);
         timing_mode = TMODE_UTC;
         have_timing_mode = 1;
      }
      have_rcvr_tmode = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb0a55(%rip), %rdi     # 0x1883c4
callq 0x7add0
leaq 0x2c34a9(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7a0f
leaq 0x2c328a(%rip), %rdi    # 0x39ac20
callq 0x9480
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xd79d6
leaq 0x294cd5(%rip), %rax    # 0x36c684
movl (%rax), %ecx
andl $-0x2, %ecx
leaq 0x294cc9(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
leaq 0x294cd9(%rip), %rax    # 0x36c69d
movb $0x0, (%rax)
leaq 0x294bde(%rip), %rax    # 0x36c5ac
movl $0x1, (%rax)
jmp 0xd7a02
leaq 0x294ca7(%rip), %rax    # 0x36c684
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x294c9b(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
leaq 0x294cab(%rip), %rax    # 0x36c69d
movb $0x3, (%rax)
leaq 0x294bb0(%rip), %rax    # 0x36c5ac
movl $0x1, (%rax)
leaq 0x294ba7(%rip), %rax    # 0x36c5b0
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_tunc()
void parse_scpi_tunc()
{
   log_packet_id("scpi tunc");

   msg_col = 0;
   if(get_msg_field()) {
      osc_offset = (float) atof(nmea_msg);
      have_osc_offset = 7;
      have_rcvr_osc = 7;
osc_offset *= 1000.0;
//    if(jitter_adev == 0) do_osc_adev(osc_offset);  // makes no sense to ADEV
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb09a2(%rip), %rdi     # 0x1883cd
callq 0x7add0
leaq 0x2c33ed(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7a9e
leaq 0x2c2fc2(%rip), %rdi    # 0x39aa10
callq 0x9480
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x293f3e(%rip), %rax    # 0x36b9a0
movsd %xmm0, (%rax)
leaq 0x2949a7(%rip), %rax    # 0x36c414
movl $0x7, (%rax)
leaq 0x2949ae(%rip), %rax    # 0x36c428
movl $0x7, (%rax)
movsd 0x975a8(%rip), %xmm0    # 0x16f030
leaq 0x293f11(%rip), %rax    # 0x36b9a0
mulsd (%rax), %xmm0
leaq 0x293f06(%rip), %rax    # 0x36b9a0
movsd %xmm0, (%rax)
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_edge()
void parse_scpi_edge()
{
   log_packet_id("scpi edge");

   msg_col = 0;
   if(get_msg_field()) {
      strupr(msg_field);
      if     (strstr(msg_field, "RIS")) {
         pps_polarity = 0;
         have_pps_polarity = 12;
      }
      else if(strstr(msg_field, "FAL")) {
         pps_polarity = 1;
         have_pps_polarity = 12;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb092c(%rip), %rdi     # 0x1883d7
callq 0x7add0
leaq 0x2c336d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7b3f
leaq 0x2c3152(%rip), %rdi    # 0x39ac20
callq 0x9890
leaq 0x2c3146(%rip), %rdi    # 0x39ac20
leaq 0xac881(%rip), %rsi     # 0x184362
callq 0x9090
cmpq $0x0, %rax
je 0xd7b08
leaq 0x295405(%rip), %rax    # 0x36cef8
movl $0x0, (%rax)
leaq 0x2949c0(%rip), %rax    # 0x36c4c0
movl $0xc, (%rax)
jmp 0xd7b3d
leaq 0x2c3111(%rip), %rdi    # 0x39ac20
leaq 0xb08cb(%rip), %rsi     # 0x1883e1
callq 0x9090
cmpq $0x0, %rax
je 0xd7b3b
leaq 0x2953d0(%rip), %rax    # 0x36cef8
movl $0x1, (%rax)
leaq 0x29498b(%rip), %rax    # 0x36c4c0
movl $0xc, (%rax)
jmp 0xd7b3d
jmp 0xd7b3f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_life()
void parse_scpi_life()
{
   log_packet_id("scpi life");

   msg_col = 0;
   if(get_msg_field()) {
      scpi_life = atoi(msg_field) * 3;
      have_lifetime = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb088a(%rip), %rdi     # 0x1883e5
callq 0x7add0
leaq 0x2c32bd(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7b9c
leaq 0x2c30a2(%rip), %rdi    # 0x39ac20
callq 0x95c0
imull $0x3, %eax, %ecx
leaq 0x294aaf(%rip), %rax    # 0x36c63c
movl %ecx, (%rax)
leaq 0x294912(%rip), %rax    # 0x36c4a8
movl $0x1, (%rax)
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_test()
void parse_scpi_test()
{
// !!! should restore com_timeout
   log_packet_id("scpi test");

   msg_col = 0;
   if(get_msg_field()) {
      scpi_test = atoi(nmea_msg);
      have_scpi_test = 1;
if(debug_file) fprintf(debug_file, "### self test:%04X\n", scpi_test);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb0868(%rip), %rdi     # 0x188413
callq 0x7add0
leaq 0x2c326d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd7c1b
leaq 0x2c2e42(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x294a3c(%rip), %rax    # 0x36c618
movl %ecx, (%rax)
leaq 0x2949fb(%rip), %rax    # 0x36c5e0
movl $0x1, (%rax)
leaq 0x1c597e(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0xd7c19
leaq 0x1c5971(%rip), %rax    # 0x29d570
movq (%rax), %rdi
leaq 0x294a0f(%rip), %rax    # 0x36c618
movl (%rax), %edx
leaq 0xb080b(%rip), %rsi     # 0x18841d
movb $0x0, %al
callq 0x9550
jmp 0xd7c1b
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_operation()
void parse_scpi_operation()
{
int status;

   log_packet_id("scpi operation");

   if(scpi_type != NORTEL_TYPE) return;

   // 0x0002 - locked
   // 0x0004 - holdover/unlocked modes
   // 0x0008 - position hold
   // 0x0010 - sats tracked
   // 0x0020 - hardware status reg set
   // 0x0040 - diagnostic log almost full
   // 0x0080 - over temp
   // 0x0100 - under temp
   // 0x0200 - antenna fault

   msg_col = 0;
   if(get_msg_field()) {
      status = atoi(nmea_msg);
if(debug_file) fprintf(debug_file, "### operation status:%04X\n", status);
      if(status & 0x0080) {       // over temperature alarm
         temperature = 71.0F;
         have_temperature = 109;
      }
      else if(status & 0x0100) {  // under temperature alarm
         temperature = (-1.0F);
         have_temperature = 110;
      }
      else {
         temperature = 30.0F;     // normal temperature
         have_temperature = 111;
      }

      if(status & 0x0010) minor_alarms &= (~MINOR_NO_TRACK);  // sat tracking OK
      else                minor_alarms |= MINOR_NO_TRACK;
      have_tracking = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb04ea(%rip), %rdi     # 0x188459
callq 0x7add0
leaq 0x1a2245(%rip), %rax    # 0x27a1c0
cmpl $0x4e, (%rax)
je 0xd7f85
jmp 0xd809b
leaq 0x2c2e98(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd809b
leaq 0x2c2a69(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, -0x4(%rbp)
leaq 0x1c55ba(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0xd7fd7
leaq 0x1c55ad(%rip), %rax    # 0x29d570
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0xb0498(%rip), %rsi     # 0x188468
movb $0x0, %al
callq 0x9550
movl -0x4(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xd8006
leaq 0x293c0d(%rip), %rax    # 0x36bbf8
movsd 0xab08d(%rip), %xmm0    # 0x183080
movsd %xmm0, (%rax)
leaq 0x29442e(%rip), %rax    # 0x36c42c
movl $0x6d, (%rax)
jmp 0xd8057
movl -0x4(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xd8035
leaq 0x293bde(%rip), %rax    # 0x36bbf8
movsd 0x970f6(%rip), %xmm0    # 0x16f118
movsd %xmm0, (%rax)
leaq 0x2943ff(%rip), %rax    # 0x36c42c
movl $0x6e, (%rax)
jmp 0xd8055
leaq 0x293bbc(%rip), %rax    # 0x36bbf8
movsd 0x9963c(%rip), %xmm0    # 0x171680
movsd %xmm0, (%rax)
leaq 0x2943dd(%rip), %rax    # 0x36c42c
movl $0x6f, (%rax)
jmp 0xd8057
movl -0x4(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xd8079
leaq 0x29434f(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $-0x9, %ecx
leaq 0x294343(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd808e
leaq 0x294338(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x29432c(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x2943db(%rip), %rax    # 0x36c470
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_ignore()
void parse_scpi_ignore()
{
u32 val;
int count;
int prn;
int flag;

   log_packet_id("scpi ignore");

   count = 0;
   val = 0;

   msg_col = 0;
   while(get_msg_field()) {
      prn = atoi(msg_field);
      if((prn >= 1) && (prn <= 32)) { 
         val |= (1 << (prn-1));
         ++count;
      }
   }

   single_sat_prn = 0;
   have_single_prn = 1;
   if(count == 31) {  // all but 1 sat excluded
      for(prn=1; prn <= 32; prn++) {
         flag = (val & (1 << (prn-1)));
         if(flag == 0) {
            single_sat_prn = prn; 
            have_single_prn = 1;
            break;
         }
      }
   }

   val = (~val);
   sats_enabled = val;
   update_disable_list(sats_enabled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb03ad(%rip), %rdi     # 0x18848c
callq 0x7add0
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
leaq 0x2c2d2b(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd8142
leaq 0x2c2b10(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0xd8140
cmpl $0x20, -0xc(%rbp)
jg 0xd8140
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd80ff
leaq 0x294173(%rip), %rax    # 0x36c2bc
movl $0x0, (%rax)
leaq 0x29416a(%rip), %rax    # 0x36c2c0
movl $0x1, (%rax)
cmpl $0x1f, -0x8(%rbp)
jne 0xd81b6
movl $0x1, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jg 0xd81b4
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0xd81a7
movl -0xc(%rbp), %ecx
leaq 0x294126(%rip), %rax    # 0x36c2bc
movl %ecx, (%rax)
leaq 0x294121(%rip), %rax    # 0x36c2c0
movl $0x1, (%rax)
jmp 0xd81b4
jmp 0xd81a9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd8169
jmp 0xd81b6
movl -0x4(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
leaq 0x2940fb(%rip), %rax    # 0x36c2c4
movl %ecx, (%rax)
leaq 0x2940f2(%rip), %rax    # 0x36c2c4
movl (%rax), %edi
callq 0x81cb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_ign_count()
void parse_scpi_ign_count()
{
int val;

   log_packet_id("scpi count");

   msg_col = 0;
   if(get_msg_field()) {
      val = atoi(msg_field);  // single_sat_prn
      if(val & (single_sat_prn == 0)) {
         single_sat_prn = 32;  // !!!!! kludge
         have_single_prn = 0;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb02a9(%rip), %rdi     # 0x188498
callq 0x7add0
leaq 0x2c2c29(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd8253
leaq 0x2c2a0e(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x294098(%rip), %rcx    # 0x36c2bc
cmpl $0x0, (%rcx)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xd8251
leaq 0x29407e(%rip), %rax    # 0x36c2bc
movl $0x20, (%rax)
leaq 0x294075(%rip), %rax    # 0x36c2c0
movl $0x0, (%rax)
jmp 0xd8253
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_include()
void parse_scpi_include()
{
u32 val;
int count;
int prn;
int last_prn;

   log_packet_id("scpi include");

   if(scpi_type != NORTEL_TYPE) return;

   count = 0;
   val = 0;
   last_prn = 0;
   msg_col = 0;
   while(get_msg_field()) {
      prn = atoi(msg_field);
      if((prn >= 1) && (prn <= 32)) { 
         val |= 1 << (prn-1);
         last_prn = prn;
         ++count;
      }
   }

   if(count == 1) single_sat_prn = last_prn; 
   else           single_sat_prn = 0;
   have_single_prn = 1;

   sats_enabled = val;
   update_disable_list(sats_enabled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb0234(%rip), %rdi     # 0x1884a3
callq 0x7add0
leaq 0x1a1f45(%rip), %rax    # 0x27a1c0
cmpl $0x4e, (%rax)
je 0xd8285
jmp 0xd8338
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0x2c2b83(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd82f0
leaq 0x2c2968(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0xd82ee
cmpl $0x20, -0xc(%rbp)
jg 0xd82ee
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd82a7
cmpl $0x1, -0x8(%rbp)
jne 0xd8304
movl -0x10(%rbp), %ecx
leaq 0x293fbc(%rip), %rax    # 0x36c2bc
movl %ecx, (%rax)
jmp 0xd8311
leaq 0x293fb1(%rip), %rax    # 0x36c2bc
movl $0x0, (%rax)
leaq 0x293fa8(%rip), %rax    # 0x36c2c0
movl $0x1, (%rax)
movl -0x4(%rbp), %ecx
leaq 0x293f9c(%rip), %rax    # 0x36c2c4
movl %ecx, (%rax)
leaq 0x293f93(%rip), %rax    # 0x36c2c4
movl (%rax), %edi
callq 0x81cb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_antenna()
void parse_scpi_antenna()
{
   log_packet_id("scpi antenna");

   minor_alarms &= (~MINOR_ANT_NO_PWR);
   if(strstr(nmea_msg, "OK")) ;
   else if(strstr(nmea_msg, "SHORT")) minor_alarms |= MINOR_ANT_SHORT;
   else if(strstr(nmea_msg, "OPEN"))  minor_alarms |= MINOR_ANT_OPEN; 
   else                               minor_alarms |= MINOR_ANT_NO_PWR; 
   have_antenna = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xafe8d(%rip), %rdi     # 0x1884e8
callq 0x7add0
leaq 0x293d51(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $-0x7, %ecx
leaq 0x293d45(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x2c2394(%rip), %rdi    # 0x39aa10
leaq 0xb2350(%rip), %rsi     # 0x18a9d3
callq 0x9090
cmpq $0x0, %rax
je 0xd8690
jmp 0xd8709
leaq 0x2c2379(%rip), %rdi    # 0x39aa10
leaq 0xafe57(%rip), %rsi     # 0x1884f5
callq 0x9090
cmpq $0x0, %rax
je 0xd86c0
leaq 0x293d08(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x4, %ecx
leaq 0x293cfc(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd8707
leaq 0x2c2349(%rip), %rdi    # 0x39aa10
leaq 0xafe2d(%rip), %rsi     # 0x1884fb
callq 0x9090
cmpq $0x0, %rax
je 0xd86f0
leaq 0x293cd8(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x293ccc(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd8705
leaq 0x293cc1(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x6, %ecx
leaq 0x293cb5(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd8707
jmp 0xd8709
leaq 0x293cfc(%rip), %rax    # 0x36c40c
movl $0x1, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_rate()
void parse_uccm_rate()
{
   log_packet_id("uccm rate");

   msg_col = 0;
   if(get_msg_field()) {
      if(strstr(msg_field, "PP1S")) {
         pps_rate = RATE_1PPS;
         have_pps_rate = 6;
//pps_enabled = 1;
      }
      else if(strstr(msg_field, "PP2S")) {
         pps_rate = RATE_PP2S;
         have_pps_rate = 6;
//pps_enabled = 1;
      }
//    have_pps_enable = 10;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xafdbf(%rip), %rdi     # 0x18850a
callq 0x7add0
leaq 0x2c26cd(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd87cd
leaq 0x2c24b2(%rip), %rdi    # 0x39ac20
leaq 0xabdd2(%rip), %rsi     # 0x184547
callq 0x9090
cmpq $0x0, %rax
je 0xd8799
leaq 0x29477c(%rip), %rax    # 0x36cf03
movb $0x2, (%rax)
leaq 0x293d1f(%rip), %rax    # 0x36c4b0
movl $0x6, (%rax)
jmp 0xd87cb
leaq 0x2c2480(%rip), %rdi    # 0x39ac20
leaq 0xabd8f(%rip), %rsi     # 0x184536
callq 0x9090
cmpq $0x0, %rax
je 0xd87c9
leaq 0x29474a(%rip), %rax    # 0x36cf03
movb $-0x7e, (%rax)
leaq 0x293ced(%rip), %rax    # 0x36c4b0
movl $0x6, (%rax)
jmp 0xd87cb
jmp 0xd87cd
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_state()
void parse_uccm_state()
{
   log_packet_id("uccm state");

   msg_col = 0;
   if(get_msg_field()) {
      if(strstr(msg_field, "ALARM")) { 
      }

      if(strstr(msg_field, "BLOCK")) {
         pps_enabled = 0;
         have_pps_enable = 10;
      }
      else if(1 || strstr(msg_field, "ACTIVE")) {
         pps_enabled = 1;
         have_pps_enable = 10;
      }
      else if(strstr(msg_field, "NORMAL")) {
         pps_enabled = 1;
         have_pps_enable = 10;
      }
      else if(strstr(msg_field, "UNLOCK")) {
         pps_enabled = 1;
         have_pps_enable = 10;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xafd39(%rip), %rdi     # 0x188514
callq 0x7add0
leaq 0x2c263d(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd885d
leaq 0x2c2422(%rip), %rdi    # 0x39ac20
leaq 0xb2126(%rip), %rsi     # 0x18a92b
callq 0x9090
cmpq $0x0, %rax
je 0xd8812
jmp 0xd8812
leaq 0x2c2407(%rip), %rdi    # 0x39ac20
leaq 0xafcff(%rip), %rsi     # 0x18851f
callq 0x9090
cmpq $0x0, %rax
je 0xd8844
leaq 0x2946ce(%rip), %rax    # 0x36cf00
movb $0x0, (%rax)
leaq 0x293c80(%rip), %rax    # 0x36c4bc
movl $0xa, (%rax)
jmp 0xd885b
leaq 0x2946b5(%rip), %rax    # 0x36cf00
movb $0x1, (%rax)
leaq 0x293c67(%rip), %rax    # 0x36c4bc
movl $0xa, (%rax)
jmp 0xd885d
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_pullin()
void parse_uccm_pullin()
{
char *s;

   log_packet_id("uccm pullin");

   msg_col = 0;
   s = strchr(nmea_msg, '[');
   if(s) {
      if(*s+1) {
         if(strstr(s+1, "UNLIMITED")) pullin_range = 0;
         else                         pullin_range = atoi(s+1);
         have_pullin = 1;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xafcb6(%rip), %rdi     # 0x188525
callq 0x7add0
leaq 0x2c25a9(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
leaq 0x2c2188(%rip), %rdi    # 0x39aa10
movl $0x5b, %esi
callq 0x9100
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd88fc
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl $0x1, %eax
cmpl $0x0, %eax
je 0xd88fa
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
leaq 0xafc76(%rip), %rsi     # 0x188531
callq 0x9090
cmpq $0x0, %rax
je 0xd88d5
leaq 0x293a7f(%rip), %rax    # 0x36c34c
movl $0x0, (%rax)
jmp 0xd88ed
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x95c0
movl %eax, %ecx
leaq 0x293a61(%rip), %rax    # 0x36c34c
movl %ecx, (%rax)
leaq 0x293a5c(%rip), %rax    # 0x36c350
movl $0x1, (%rax)
jmp 0xd88fc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_hw_alarm()
void parse_uccm_hw_alarm()
{
   log_packet_id("uccm hw alarm");

   msg_col = 0;
   if(get_msg_field()) {
      have_critical_alarms = 666;
      critical_alarms &= (~CRIT_PWR);
      if(strstr(msg_field, "POWER")) {   // SAMSUNG_TYPE
         critical_alarms |= (CRIT_PWR);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xafc20(%rip), %rdi     # 0x18853b
callq 0x7add0
leaq 0x2c24fd(%rip), %rax    # 0x39ae24
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xd8989
leaq 0x293b4a(%rip), %rax    # 0x36c488
movl $0x29a, (%rax)          # imm = 0x29A
leaq 0x293a65(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
andl $-0x5, %ecx
leaq 0x293a59(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
leaq 0x2c22c0(%rip), %rdi    # 0x39ac20
leaq 0xafbe2(%rip), %rsi     # 0x188549
callq 0x9090
cmpq $0x0, %rax
je 0xd8987
leaq 0x293a37(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x4, %ecx
leaq 0x293a2b(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
jmp 0xd8989
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_status()
void parse_scpi_status()
{
//if(debug_file) fprintf(debug_file, "%s\n", nmea_msg);

   // decode the HIDEIOUS multi-line SCPI STATUS message (that takes three
   // seconds for the receiver to send.
   log_packet_id("scpi status");

   scpi_status = 1;
   saw_uccm_dmode = 0;
   scpi_tracked = scpi_not_tracked = 0;
   scpi_col = 0;
   scpi_status_line[0] = 0;
   no_uccm_ref = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xafb94(%rip), %rdi     # 0x18855f
callq 0x7add0
movl $0x1, 0x2f67da(%rip)    # 0x3cf1b4
leaq 0x1a1817(%rip), %rax    # 0x27a1f8
movl $0x0, (%rax)
movl $0x0, 0x2f86d7(%rip)    # 0x3d10c8
movl $0x0, 0x2f86c9(%rip)    # 0x3d10c4
movl $0x0, 0x2f338f(%rip)    # 0x3cbd94
movb $0x0, 0x2f3304(%rip)    # 0x3cbd10
movl $0x0, 0x2f67a2(%rip)    # 0x3cf1b8
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_loop()
void parse_uccm_loop()
{
   // prepare to decode the multi-line UCCM LOOP status message 
   log_packet_id("uccm loop");

   uccm_loop = 1;
   loop_fmt = TRIMBLE_FMT;   // assume Trimble format
   scpi_col = 0;
   scpi_status_line[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xaee48(%rip), %rdi     # 0x1888b3
callq 0x7add0
movl $0x1, 0x2f5742(%rip)    # 0x3cf1bc
movl $0x0, 0x2f573c(%rip)    # 0x3cf1c0
movl $0x0, 0x2f2306(%rip)    # 0x3cbd94
movb $0x0, 0x2f227b(%rip)    # 0x3cbd10
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_temp()
void parse_uccm_temp()
{
char *s;

   log_packet_id("uccm temp");

   s = strstr(nmea_msg, "TEMP = ");  // samsung
   if(s) {
      temperature = (DATA_SIZE) atof(s+7);
      if(user_set_temp_plot == 0) plot[TEMP].show_plot = 1;
      have_temperature = 112;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xaead6(%rip), %rdi     # 0x188925
callq 0x7add0
leaq 0x2c0bb5(%rip), %rdi    # 0x39aa10
leaq 0xaeacd(%rip), %rsi     # 0x18892f
callq 0x9090
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd9eb7
movq -0x8(%rbp), %rdi
addq $0x7, %rdi
callq 0x9480
leaq 0x291d72(%rip), %rax    # 0x36bbf8
movsd %xmm0, (%rax)
leaq 0x2931b1(%rip), %rax    # 0x36d042
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xd9eaa
leaq 0xe2e80(%rip), %rax     # 0x1bcd20
movl $0x1, 0x2d0(%rax)
leaq 0x29257b(%rip), %rax    # 0x36c42c
movl $0x70, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: uccm_time_line(int)
int uccm_time_line(int why)
{

   // this routine handles the case where the Symmetricom units send a 
   // time code packet in the middle of another message's response
   
   if(scpi_status_line[0] != 'C') return 0;  // line is not a time code line
   if(scpi_status_line[1] != '5') return 0;

   strcpy(nmea_msg, scpi_status_line);  // prepare to decode the time code line
   parse_uccm_time(why);                   // decode it

   scpi_col = 0;              // prepare to get the next line
   scpi_status_line[0] = 0;

   poll_next_uccm();  //kkkkkk
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movsbl 0x2f1e3e(%rip), %eax    # 0x3cbd10
cmpl $0x43, %eax
je 0xd9ee0
movl $0x0, -0x4(%rbp)
jmp 0xd9f2d
movsbl 0x2f1e2a(%rip), %eax    # 0x3cbd11
cmpl $0x35, %eax
je 0xd9ef5
movl $0x0, -0x4(%rbp)
jmp 0xd9f2d
leaq 0x2c0b14(%rip), %rdi    # 0x39aa10
leaq 0x2f1e0d(%rip), %rsi    # 0x3cbd10
callq 0x9350
movl -0x8(%rbp), %edi
callq 0xd9aa0
movl $0x0, 0x2f1e7a(%rip)    # 0x3cbd94
movb $0x0, 0x2f1def(%rip)    # 0x3cbd10
callq 0x98dd0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: decode_uccm_temp()
void decode_uccm_temp()
{
char *s;

   if(have_temperature) return;  // samsung

   s = strstr(scpi_status_line, "=");   //kkkkk
   if(s) {
      temperature = (float) atof(s+1);
      temperature *= 1.0E12F;
      if(temperature) have_uccm_tcor = 1;
      if(have_uccm_tcor) plot[TEMP].plot_id = "TCOR";
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x29166d(%rip), %rax    # 0x36c42c
cmpl $0x0, (%rax)
je 0xdadc9
jmp 0xdae71
leaq 0x2f0f40(%rip), %rdi    # 0x3cbd10
leaq 0x97474(%rip), %rsi     # 0x17224b
callq 0x9090
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xdae71
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x9480
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x290df1(%rip), %rax    # 0x36bbf8
movsd %xmm0, (%rax)
movsd 0xa8275(%rip), %xmm0    # 0x183088
leaq 0x290dde(%rip), %rax    # 0x36bbf8
mulsd (%rax), %xmm0
leaq 0x290dd3(%rip), %rax    # 0x36bbf8
movsd %xmm0, (%rax)
leaq 0x290dc8(%rip), %rax    # 0x36bbf8
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xdae41
jp 0xdae41
jmp 0xdae4e
leaq 0x19f39c(%rip), %rax    # 0x27a1e4
movl $0x1, (%rax)
leaq 0x19f38f(%rip), %rax    # 0x27a1e4
cmpl $0x0, (%rax)
je 0xdae6f
leaq 0xe1ebf(%rip), %rax     # 0x1bcd20
leaq 0x956a2(%rip), %rcx     # 0x17050a
movq %rcx, 0x2b8(%rax)
jmp 0xdae71
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: decode_uccm_phase()
void decode_uccm_phase()
{
char *s;

   s = strstr(scpi_status_line, "=");   //kkkkk
   if(s) {
      pcorr = atof(s+1) * 1.0E12;
      have_uccm_pcor = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2f0e81(%rip), %rdi    # 0x3cbd10
leaq 0x973b5(%rip), %rsi     # 0x17224b
callq 0x9090
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xdaed7
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x9480
movsd 0x942b5(%rip), %xmm1    # 0x16f170
mulsd %xmm1, %xmm0
leaq 0x290d42(%rip), %rax    # 0x36bc08
movsd %xmm0, (%rax)
leaq 0x19f317(%rip), %rax    # 0x27a1e8
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: decode_uccm_gps_phase()
void decode_uccm_gps_phase()
{
char *s;

   s = strstr(scpi_status_line, "=");   //kkkkk
   if(s) {
      uccm_gps_phase = atof(s+1);
      have_uccm_gps_phase = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2f0e21(%rip), %rdi    # 0x3cbd10
leaq 0x97355(%rip), %rsi     # 0x17224b
callq 0x9090
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xdaf2b
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x9480
leaq 0x290cf6(%rip), %rax    # 0x36bc10
movsd %xmm0, (%rax)
leaq 0x19f2c7(%rip), %rax    # 0x27a1ec
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: poll_cs_log()
void poll_cs_log()
{
static int log_req_tick;
static int all_log_req = 0;
static int last_log_req = 0;
int i;

   if(cs_log_count <= CS_LOG_SHOW) {
      send_polled_cmd("DIAG:LOG?", CS_LOGINFO_MSG);
   }
   else if(log_req_tick & 1) {  // alternate requests for all log entries and last log entries
      if(all_log_req >= cs_log_count) all_log_req = 0;
      sprintf(out, "DIAG:LOG?  %d", all_log_req);
      send_polled_cmd(out, CS_LOGINFO_MSG);
      all_log_req = (all_log_req + 1) % MAX_CS_LOGS;
   }
   else {
      i = cs_log_count - last_log_req - 1;
      if(i >= 0) {
         sprintf(out, "DIAG:LOG? %d", i);
         send_polled_cmd(out, CS_LOGINFO_MSG);
      }
      last_log_req = (last_log_req + 1) % CS_LOG_SHOW;
   }

   ++log_req_tick;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x19d3c5(%rip), %rax    # 0x279ad4
cmpl $0x8, (%rax)
jg 0xdc72a
leaq 0xac3aa(%rip), %rdi     # 0x188ac5
movl $0x14b, %esi            # imm = 0x14B
callq 0x96370
jmp 0xdc7f5
movl 0x2f4ac8(%rip), %eax    # 0x3d11f8
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdc798
movl 0x2f4abe(%rip), %eax    # 0x3d11fc
leaq 0x19d38f(%rip), %rcx    # 0x279ad4
cmpl (%rcx), %eax
jl 0xdc753
movl $0x0, 0x2f4aa9(%rip)    # 0x3d11fc
movl 0x2f4aa3(%rip), %edx    # 0x3d11fc
leaq 0x2beca0(%rip), %rdi    # 0x39b400
leaq 0xac368(%rip), %rsi     # 0x188acf
movb $0x0, %al
callq 0x9060
leaq 0x2bec8b(%rip), %rdi    # 0x39b400
movl $0x14b, %esi            # imm = 0x14B
callq 0x96370
movl 0x2f4a77(%rip), %eax    # 0x3d11fc
addl $0x1, %eax
movl $0xc0, %ecx
cltd
idivl %ecx
movl %edx, 0x2f4a66(%rip)    # 0x3d11fc
jmp 0xdc7f3
leaq 0x19d335(%rip), %rax    # 0x279ad4
movl (%rax), %eax
subl 0x2f4a59(%rip), %eax    # 0x3d1200
subl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xdc7dc
movl -0x4(%rbp), %edx
leaq 0x2bec43(%rip), %rdi    # 0x39b400
leaq 0xac319(%rip), %rsi     # 0x188add
movb $0x0, %al
callq 0x9060
leaq 0x2bec2e(%rip), %rdi    # 0x39b400
movl $0x14b, %esi            # imm = 0x14B
callq 0x96370
movl 0x2f4a1e(%rip), %eax    # 0x3d1200
addl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, 0x2f4a0d(%rip)    # 0x3d1200
jmp 0xdc7f5
movl 0x2f49fd(%rip), %eax    # 0x3d11f8
addl $0x1, %eax
movl %eax, 0x2f49f4(%rip)    # 0x3d11f8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)