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

   log_packet_id("receiver id");

   get_zod_seq(0);

   for(i=0; i<20; i++) {
      zod_chans[i] = tsip_byte();
      zod_chans[i+1] = 0;
   }

   for(i=0; i<20; i++) {
      zod_sw[i] = tsip_byte();
      zod_sw[i+1] = 0;
   }

   for(i=0; i<20; i++) {
      zod_date[i] = tsip_byte();
      zod_date[i+1] = 0;
   }

   for(i=0; i<20; i++) {
      zod_opt[i] = tsip_byte();
      zod_opt[i+1] = 0;

   }

   for(i=0; i<20; i++) {
      zod_rsvd[i] = tsip_byte();
      zod_rsvd[i+1] = 0;
   }

   have_info |= ALL_ID_INFO;

// show_version_info();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb6f5d(%rip), %rdi     # 0x187e9c
callq 0x7add0
xorl %edi, %edi
callq 0xd0040
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0xd0f8c
callq 0x7a510
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x2cc086(%rip), %rax    # 0x39cff0
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x2cc073(%rip), %rax    # 0x39cff0
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd0f52
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0xd0fcd
callq 0x7a510
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x2cc065(%rip), %rax    # 0x39d010
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x2cc052(%rip), %rax    # 0x39d010
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd0f93
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0xd100e
callq 0x7a510
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x2cc044(%rip), %rax    # 0x39d030
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x2cc031(%rip), %rax    # 0x39d030
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd0fd4
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0xd104f
callq 0x7a510
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x2cc023(%rip), %rax    # 0x39d050
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x2cc010(%rip), %rax    # 0x39d050
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd1015
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0xd1090
callq 0x7a510
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x2cc002(%rip), %rax    # 0x39d070
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x2cbfef(%rip), %rax    # 0x39d070
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd1056
leaq 0x29babd(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0xf, %ecx
leaq 0x29bab1(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zod_settings()
void parse_zod_settings()
{
u16 snr_threshold;
u16 elev;
u16 platform;

   log_packet_id("setttings");

   get_zod_seq(0);

   zod_nav_flags = tsip_word();
   snr_threshold = ((zod_nav_flags >> 9) & 0x7F);

   tsip_word();        // col start timeout
   tsip_word();        // dgps timeout

   elev = tsip_word();
   el_mask = (float) elev;
   el_mask += 0.005F;
   el_mask = el_mask * (float) ((180.0/PI) / 1000.0);
   have_el_mask = 1;

   sats_enabled = tsip_dword();  // selected sats bit mask
   tsip_word();        // solution flags
   tsip_word();        // required sat count
   tsip_dword();       // required horiz err
   tsip_dword();       // required vert err
   platform = tsip_word();

   update_disable_list(sats_enabled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb6de9(%rip), %rdi     # 0x187ea8
callq 0x7add0
xorl %edi, %edi
callq 0xd0040
callq 0x7a560
movw %ax, 0x2fac35(%rip)     # 0x3cbd0c
movzwl 0x2fac2e(%rip), %eax    # 0x3cbd0c
shrl $0x9, %eax
movw %ax, -0x2(%rbp)
callq 0x7a560
callq 0x7a560
callq 0x7a560
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
cvtsi2ss %eax, %xmm0
leaq 0x29b18d(%rip), %rax    # 0x36c294
movss %xmm0, (%rax)
movss 0xb2299(%rip), %xmm0    # 0x1833ac
leaq 0x29b17a(%rip), %rax    # 0x36c294
addss (%rax), %xmm0
leaq 0x29b16f(%rip), %rax    # 0x36c294
movss %xmm0, (%rax)
movss 0xb2277(%rip), %xmm0    # 0x1833a8
leaq 0x29b15c(%rip), %rax    # 0x36c294
mulss (%rax), %xmm0
leaq 0x29b151(%rip), %rax    # 0x36c294
movss %xmm0, (%rax)
leaq 0x29b48e(%rip), %rax    # 0x36c5dc
movl $0x1, (%rax)
callq 0x7a680
movl %eax, %ecx
leaq 0x29b162(%rip), %rax    # 0x36c2c4
movl %ecx, (%rax)
callq 0x7a560
callq 0x7a560
callq 0x7a680
callq 0x7a680
callq 0x7a560
movw %ax, -0x6(%rbp)
leaq 0x29b13c(%rip), %rax    # 0x36c2c4
movl (%rax), %edi
callq 0x81cb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zod_diags()
void parse_zod_diags()
{
int ram;
int rom;
int ee;
int dp_ram;
int dsp;
int rtc;

   log_packet_id("diagnostics");

   get_zod_seq(0);
   rom = tsip_word();
   ram = tsip_word();
   ee  = tsip_word();
   dp_ram = tsip_word();
   dsp = tsip_word();
   rtc = tsip_word();

   tsip_word();   // serial port stats
   tsip_word();
   tsip_word();
   tsip_word();

   critical_alarms = 0;
   if(have_eeprom == 0) ee = 0;
   minor_alarms &= (~MINOR_EEPROM);

   if(rom) critical_alarms |= CRIT_ROM;   // ROM
   if(rtc) critical_alarms |= CRIT_OCXO;  // 1KHz / DCXO
   if(dsp) critical_alarms |= CRIT_FPGA;  // FPGA
   if(ram | dp_ram) critical_alarms |= CRIT_RAM;  // RAM
   if(ee) {
      minor_alarms |= MINOR_EEPROM;      // EEPROM
      have_eeprom = 1;
   }
   if(!have_critical_alarms) need_redraw = 7703;
   have_critical_alarms = 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xa1932(%rip), %rdi     # 0x172ae1
callq 0x7add0
xorl %edi, %edi
callq 0xd0040
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x8(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0xc(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x10(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x18(%rbp)
callq 0x7a560
callq 0x7a560
callq 0x7a560
callq 0x7a560
leaq 0x29b198(%rip), %rax    # 0x36c3b0
movl $0x0, (%rax)
leaq 0x29b267(%rip), %rax    # 0x36c48c
cmpl $0x0, (%rax)
jne 0xd1231
movl $0x0, -0xc(%rbp)
leaq 0x29b180(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
leaq 0x29b171(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
je 0xd1264
leaq 0x29b15a(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x29b14e(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
cmpl $0x0, -0x18(%rbp)
je 0xd127f
leaq 0x29b13f(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x10, %ecx
leaq 0x29b133(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
cmpl $0x0, -0x14(%rbp)
je 0xd129a
leaq 0x29b124(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x29b118(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
orl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0xd12ba
leaq 0x29b104(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x29b0f8(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
cmpl $0x0, -0xc(%rbp)
je 0xd12e5
leaq 0x29b0f1(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
leaq 0x29b0e2(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x29b1ad(%rip), %rax    # 0x36c48c
movl $0x1, (%rax)
leaq 0x29b19c(%rip), %rax    # 0x36c488
cmpl $0x0, (%rax)
jne 0xd12fe
leaq 0x1a672c(%rip), %rax    # 0x277a24
movl $0x1e17, (%rax)         # imm = 0x1E17
leaq 0x29b183(%rip), %rax    # 0x36c488
movl $0x3, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_zod_protocol(int)
void set_zod_protocol(int prot)
{
   if(read_only) return;

   if(prot < 0) return;
   if(prot > 1) return;

   send_zod_start(ZOD_SET_PROTOCOL, 9, 0);
   send_zod_seq();
   send_word(0);
   send_word(prot);
   send_zod_end();

   Sleep(250);
   if     (prot == 0) rcvr_type = ZODIAC_RCVR;
   else if(prot == 1) rcvr_type = NMEA_RCVR;
   config_rcvr_type(0);
   need_msg_init = 2006;
   init_messages(60, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2c4ec8(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xd133c
jmp 0xd13d8
cmpl $0x0, -0x4(%rbp)
jge 0xd1347
jmp 0xd13d8
cmpl $0x1, -0x4(%rbp)
jle 0xd1352
jmp 0xd13d8
movl $0x533, %edi            # imm = 0x533
movl $0x9, %esi
xorl %edx, %edx
callq 0x89bf0
callq 0x89d10
xorl %edi, %edi
callq 0x7b4b0
movl -0x4(%rbp), %eax
movzwl %ax, %edi
callq 0x7b4b0
callq 0x89d30
movl $0xfa, %edi
callq 0xb8b0
cmpl $0x0, -0x4(%rbp)
jne 0xd139f
leaq 0x1a671a(%rip), %rax    # 0x277ab0
movq $0x100, (%rax)          # imm = 0x100
jmp 0xd13b5
cmpl $0x1, -0x4(%rbp)
jne 0xd13b3
leaq 0x1a6704(%rip), %rax    # 0x277ab0
movq $0x2, (%rax)
jmp 0xd13b5
xorl %edi, %edi
callq 0x6a330
leaq 0x1a8e4d(%rip), %rax    # 0x27a210
movl $0x7d6, (%rax)          # imm = 0x7D6
movl $0x3c, %edi
movl $0x1, %esi
callq 0x86290
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_zod_power(int)
void set_zod_power(int power)
{
   if(read_only) return;

   send_zod_start(ZOD_SET_POWER, 8, 0);
   send_zod_seq();
   send_word(power);
   send_zod_end();
   Sleep(100);

   query_zod_msg(ZOD_POWER_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2c4e08(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xd13f9
jmp 0xd1433
movl $0x525, %edi            # imm = 0x525
movl $0x8, %esi
xorl %edx, %edx
callq 0x89bf0
callq 0x89d10
movl -0x4(%rbp), %eax
movzwl %ax, %edi
callq 0x7b4b0
callq 0x89d30
movl $0x64, %edi
callq 0xb8b0
movl $0x45d, %edi            # imm = 0x45D
callq 0x8b850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: set_zod_platform(int)
void set_zod_platform(int platform)
{
   if(read_only) return;

   send_zod_start(ZOD_SET_PLATFORM, 8, 0);
   send_zod_seq();
   send_word(platform);
   send_zod_end();
   Sleep(100);

   query_zod_msg(ZOD_SETTINGS_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2c4da8(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xd1459
jmp 0xd1493
movl $0x4c4, %edi            # imm = 0x4C4
movl $0x8, %esi
xorl %edx, %edx
callq 0x89bf0
callq 0x89d10
movl -0x4(%rbp), %eax
movzwl %ax, %edi
callq 0x7b4b0
callq 0x89d30
movl $0x64, %edi
callq 0xb8b0
movl $0x3f4, %edi            # imm = 0x3F4
callq 0x8b850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: decode_zod_message()
void decode_zod_message()
{
u16 id;

   start_msg_decode(1);

   id = zodiac_hdr[0];

   if     (id == ZOD_POSN_MSG)         parse_zod_posn();
   else if(id == ZOD_SNR_MSG)          parse_zod_snr();
   else if(id == ZOD_VIS_MSG)          parse_zod_vis();
   else if(id == ZOD_TRAIM_STATUS_MSG) parse_zod_traim_status();
   else if(id == ZOD_TRAIM_CONFIG_MSG) parse_zod_traim_config();
   else if(id == ZOD_DIAG_MSG)         parse_zod_diags();
   else if(id == ZOD_MARK_MSG)         parse_zod_mark();
   else if(id == ZOD_TEMP_MSG)         parse_zod_temp();
   else if(id == ZOD_EE_WRITE_MSG)     parse_zod_ee_written();
   else if(id == ZOD_EE_STATUS_MSG)    parse_zod_ee_status();
   else if(id == ZOD_POWER_MSG)        parse_zod_power();
   else if(id == ZOD_SETTINGS_MSG)     parse_zod_settings();
   else if(id == ZOD_ID_MSG)           parse_zod_id();
// else sprintf(debug_text, "unk zod msg:%d", id);

   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
movl $0x1, %edi
callq 0xae4a0
movw 0x2fa849(%rip), %ax     # 0x3cbd02
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x3e8, %eax            # imm = 0x3E8
jne 0xd14d2
callq 0xd0a70
jmp 0xd15cf
movzwl -0x2(%rbp), %eax
cmpl $0x3ea, %eax            # imm = 0x3EA
jne 0xd14e7
callq 0xd0170
jmp 0xd15cd
movzwl -0x2(%rbp), %eax
cmpl $0x3eb, %eax            # imm = 0x3EB
jne 0xd14fc
callq 0xd0360
jmp 0xd15cb
movzwl -0x2(%rbp), %eax
cmpl $0x420, %eax            # imm = 0x420
jne 0xd1511
callq 0xd08a0
jmp 0xd15c9
movzwl -0x2(%rbp), %eax
cmpl $0x41f, %eax            # imm = 0x41F
jne 0xd1526
callq 0xd06f0
jmp 0xd15c7
movzwl -0x2(%rbp), %eax
cmpl $0x44c, %eax            # imm = 0x44C
jne 0xd153b
callq 0xd11a0
jmp 0xd15c5
movzwl -0x2(%rbp), %eax
cmpl $0x454, %eax            # imm = 0x454
jne 0xd154d
callq 0xd0580
jmp 0xd15c3
movzwl -0x2(%rbp), %eax
cmpl $0x456, %eax            # imm = 0x456
jne 0xd155f
callq 0xd0080
jmp 0xd15c1
movzwl -0x2(%rbp), %eax
cmpl $0x46f, %eax            # imm = 0x46F
jne 0xd1571
callq 0xd0e30
jmp 0xd15bf
movzwl -0x2(%rbp), %eax
cmpl $0x470, %eax            # imm = 0x470
jne 0xd1583
callq 0xd0e80
jmp 0xd15bd
movzwl -0x2(%rbp), %eax
cmpl $0x45d, %eax            # imm = 0x45D
jne 0xd1595
callq 0xd0f00
jmp 0xd15bb
movzwl -0x2(%rbp), %eax
cmpl $0x3f4, %eax            # imm = 0x3F4
jne 0xd15a7
callq 0xd10b0
jmp 0xd15b9
movzwl -0x2(%rbp), %eax
cmpl $0x3f3, %eax            # imm = 0x3F3
jne 0xd15b7
callq 0xd0f30
jmp 0xd15b9
jmp 0xd15bb
jmp 0xd15bd
jmp 0xd15bf
jmp 0xd15c1
jmp 0xd15c3
jmp 0xd15c5
jmp 0xd15c7
jmp 0xd15c9
jmp 0xd15cb
jmp 0xd15cd
jmp 0xd15cf
leaq 0x1cbfca(%rip), %rax    # 0x29d5a0
cmpq $0x0, (%rax)
je 0xd15fa
leaq 0x1b11fd(%rip), %rax    # 0x2827e0
cmpq $0x0, (%rax)
je 0xd15fa
leaq 0x1b11f0(%rip), %rax    # 0x2827e0
movq (%rax), %rax
movl %eax, %edi
callq 0xb8b0
leaq 0x1ccb7f(%rip), %rax    # 0x29e180
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_moto_lla()
void get_moto_lla()
{
   // get lat/lon/alt fields from a motorola binary message

   lat = ((double) (S32) tsip_dword());  // filtered or unfiltered posn
   lon = ((double) (S32) tsip_dword());
   alt = ((double) (S32) tsip_dword());  // gps altitude

   lat = (lat / 3600000.0) * PI / 180.0; // milliarcseconds to radians
   lon = (lon / 3600000.0) * PI / 180.0;
   alt /= 100.0;  // convert cm to meters
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x7a680
cvtsi2sd %eax, %xmm0
leaq 0x29a6dc(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
callq 0x7a680
cvtsi2sd %eax, %xmm0
leaq 0x29a6d0(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
callq 0x7a680
cvtsi2sd %eax, %xmm0
leaq 0x29a6c4(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
leaq 0x29a6a9(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
movsd 0xb10b5(%rip), %xmm1    # 0x182bc8
divsd %xmm1, %xmm0
movsd 0x9faa9(%rip), %xmm1    # 0x1715c8
mulsd %xmm1, %xmm0
movsd 0x9d54d(%rip), %xmm1    # 0x16f078
divsd %xmm1, %xmm0
leaq 0x29a67a(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
leaq 0x29a677(%rip), %rax    # 0x36c1b8
movsd (%rax), %xmm0
movsd 0xb107b(%rip), %xmm1    # 0x182bc8
divsd %xmm1, %xmm0
movsd 0x9fa6f(%rip), %xmm1    # 0x1715c8
mulsd %xmm1, %xmm0
movsd 0x9d513(%rip), %xmm1    # 0x16f078
divsd %xmm1, %xmm0
leaq 0x29a648(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
leaq 0x29a645(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm0
movsd 0x9d4c9(%rip), %xmm1    # 0x16f050
divsd %xmm1, %xmm0
leaq 0x29a62e(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_moto_time(int)
void get_moto_time(int set_time)
{
   if(set_time) {
      pri_month = month = tsip_byte();
      pri_day = day = tsip_byte();
      pri_year = year = tsip_word();
      pri_hours = hours = tsip_byte();
      pri_minutes = minutes = tsip_byte();
      pri_seconds = seconds = tsip_byte();
      pri_frac = raw_frac = 0.0;
   }
   else {
      tsip_byte();
      tsip_byte();
      tsip_word();
      tsip_byte();
      tsip_byte();
      tsip_byte();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xd1c6f
callq 0x7a510
movzbl %al, %ecx
leaq 0x29aaf4(%rip), %rax    # 0x36c6b8
movl %ecx, (%rax)
leaq 0x29ab23(%rip), %rax    # 0x36c6f0
movl %ecx, (%rax)
callq 0x7a510
movzbl %al, %ecx
leaq 0x29aad6(%rip), %rax    # 0x36c6b4
movl %ecx, (%rax)
leaq 0x29ab05(%rip), %rax    # 0x36c6ec
movl %ecx, (%rax)
callq 0x7a560
movzwl %ax, %ecx
leaq 0x29aac4(%rip), %rax    # 0x36c6bc
movl %ecx, (%rax)
leaq 0x29aaf3(%rip), %rax    # 0x36c6f4
movl %ecx, (%rax)
callq 0x7a510
movzbl %al, %ecx
leaq 0x29aa9e(%rip), %rax    # 0x36c6b0
movl %ecx, (%rax)
leaq 0x29aacd(%rip), %rax    # 0x36c6e8
movl %ecx, (%rax)
callq 0x7a510
movzbl %al, %ecx
leaq 0x29aa80(%rip), %rax    # 0x36c6ac
movl %ecx, (%rax)
leaq 0x29aaaf(%rip), %rax    # 0x36c6e4
movl %ecx, (%rax)
callq 0x7a510
movzbl %al, %ecx
leaq 0x29aa62(%rip), %rax    # 0x36c6a8
movl %ecx, (%rax)
leaq 0x29aa91(%rip), %rax    # 0x36c6e0
movl %ecx, (%rax)
leaq 0x29aa68(%rip), %rax    # 0x36c6c0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x29aa92(%rip), %rax    # 0x36c6f8
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0xd1c8d
callq 0x7a510
callq 0x7a510
callq 0x7a560
callq 0x7a510
callq 0x7a510
callq 0x7a510
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: decode_posn_mode()
void decode_posn_mode()
{
   // convert position mode word into tbolt equivalents

   set_survey_status(0);

   if     (posn_mode == 0) rcvr_mode = RCVR_MODE_3D;
   else if(posn_mode == 1) rcvr_mode = RCVR_MODE_HOLD;
   else if(posn_mode == 2) rcvr_mode = RCVR_MODE_2D;
   else if(posn_mode == 3) set_survey_status(1);
   have_rcvr_mode = 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0xd1cc0
leaq 0x1a85ba(%rip), %rax    # 0x27a2cc
cmpl $0x0, (%rax)
jne 0xd1d23
leaq 0x29a592(%rip), %rax    # 0x36c2b0
movb $0x4, (%rax)
jmp 0xd1d6f
leaq 0x1a85a2(%rip), %rax    # 0x27a2cc
cmpl $0x1, (%rax)
jne 0xd1d3b
leaq 0x29a57a(%rip), %rax    # 0x36c2b0
movb $0x7, (%rax)
jmp 0xd1d6d
leaq 0x1a858a(%rip), %rax    # 0x27a2cc
cmpl $0x2, (%rax)
jne 0xd1d53
leaq 0x29a562(%rip), %rax    # 0x36c2b0
movb $0x3, (%rax)
jmp 0xd1d6b
leaq 0x1a8572(%rip), %rax    # 0x27a2cc
cmpl $0x3, (%rax)
jne 0xd1d69
movl $0x1, %edi
callq 0xd1cc0
jmp 0xd1d6b
jmp 0xd1d6d
jmp 0xd1d6f
leaq 0x29a877(%rip), %rax    # 0x36c5ed
movb $0x4, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_moto_tag()
void get_moto_tag()
{
   id_tag[0] = tsip_byte();  // id string
   id_tag[1] = tsip_byte();
   id_tag[2] = tsip_byte();
   id_tag[3] = tsip_byte();
   id_tag[4] = tsip_byte();
   id_tag[5] = tsip_byte();
   id_tag[6] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x7a510
movb %al, 0x2f9cdd(%rip)     # 0x3cbcac
callq 0x7a510
movb %al, 0x2f9cd3(%rip)     # 0x3cbcad
callq 0x7a510
movb %al, 0x2f9cc9(%rip)     # 0x3cbcae
callq 0x7a510
movb %al, 0x2f9cbf(%rip)     # 0x3cbcaf
callq 0x7a510
movb %al, 0x2f9cb5(%rip)     # 0x3cbcb0
callq 0x7a510
movb %al, 0x2f9cab(%rip)     # 0x3cbcb1
movb $0x0, 0x2f9ca5(%rip)    # 0x3cbcb2
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Af()
void parse_moto_Af()
{
   log_packet_id("altitude");
   alt = ((double) (S32) tsip_dword());  // GPS height in cm
   tsip_dword();                         // MSL height in cm
   alt = (alt / 100.0); // cm to meters
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb5e05(%rip), %rdi     # 0x187ee0
callq 0x7add0
callq 0x7a680
cvtsi2sd %eax, %xmm0
leaq 0x29a0d0(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
callq 0x7a680
leaq 0x29a0c0(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm0
movsd 0x9cf44(%rip), %xmm1    # 0x16f050
divsd %xmm1, %xmm0
leaq 0x29a0a9(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Am()
void parse_moto_Am()
{
u32 val;

   log_packet_id("ignore sats");
   tsip_byte();
   val = tsip_dword();  // sat ignore bitmask

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb5d7a(%rip), %rdi     # 0x187ee9
callq 0x7add0
callq 0x7a510
callq 0x7a680
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
leaq 0x29a130(%rip), %rax    # 0x36c2c4
movl %ecx, (%rax)
leaq 0x29a127(%rip), %rax    # 0x36c2c4
movl (%rax), %edi
callq 0x81cb0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_AN()
void parse_moto_AN()
{
u08 v_filter;

   // marine velocity filter
   log_packet_id("marine filter");
   v_filter = tsip_byte();
   marine_filter = v_filter;
   if((v_filter >= 10) && (v_filter <= 100)) have_filter |= MARINE_FILTER;
   else                                      have_filter &= (~MARINE_FILTER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb5d36(%rip), %rdi     # 0x187ef5
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %cl
leaq 0x29a0a9(%rip), %rax    # 0x36c27f
movb %cl, (%rax)
movzbl -0x1(%rbp), %eax
cmpl $0xa, %eax
jl 0xd2204
movzbl -0x1(%rbp), %eax
cmpl $0x64, %eax
jg 0xd2204
leaq 0x29a07f(%rip), %rax    # 0x36c270
movl (%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
leaq 0x29a070(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
jmp 0xd221c
leaq 0x29a065(%rip), %rax    # 0x36c270
movl (%rax), %ecx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
leaq 0x29a056(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Aq()
void parse_moto_Aq()
{
u08 iono;

   // ionosphere corrections
   log_packet_id("iono/tropo filters");
   iono = tsip_byte();  // 0x01=iono, 0x02:tropo
   if(iono & 0x01) static_filter = 1;
   else            static_filter = 0;
   have_filter |= STATIC_FILTER;

   // troposphere corrections
   if(iono & 0x02) alt_filter = 1;
   else            alt_filter = 0;
   have_filter |= ALT_FILTER;
//sprintf(plot_title, "iono:%02x", iono);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb5c88(%rip), %rdi     # 0x187f17
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd22b4
leaq 0x299fca(%rip), %rax    # 0x36c279
movb $0x1, (%rax)
jmp 0xd22be
leaq 0x299fbe(%rip), %rax    # 0x36c279
movb $0x0, (%rax)
leaq 0x299fab(%rip), %rax    # 0x36c270
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x299f9f(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
movzbl -0x1(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xd22eb
leaq 0x299f94(%rip), %rax    # 0x36c27a
movb $0x1, (%rax)
jmp 0xd22f5
leaq 0x299f88(%rip), %rax    # 0x36c27a
movb $0x0, (%rax)
leaq 0x299f74(%rip), %rax    # 0x36c270
movl (%rax), %ecx
orl $0x4, %ecx
leaq 0x299f68(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_AQ()
void parse_moto_AQ()
{
u08 v_filter;

   // position filter
   log_packet_id("pv filter");
   v_filter = tsip_byte();
   pv_filter = v_filter;
   have_filter |= PV_FILTER;
//sprintf(debug_text, "Pfilter:%02x", pv_filter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb5c0b(%rip), %rdi     # 0x187f2a
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %cl
leaq 0x299f42(%rip), %rax    # 0x36c278
movb %cl, (%rax)
leaq 0x299f31(%rip), %rax    # 0x36c270
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x299f25(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Ay()
void parse_moto_Ay()
{
   // pps delay
   log_packet_id("pps delay");
   pps1_delay = (double) (S32) tsip_dword();
   have_pps_delay |= 0x01;
   show_cable_delay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb5b83(%rip), %rdi     # 0x187f4e
callq 0x7add0
callq 0x7a680
cvtsi2sd %eax, %xmm0
leaq 0x29abd8(%rip), %rax    # 0x36cfb8
movsd %xmm0, (%rax)
leaq 0x29a0ad(%rip), %rax    # 0x36c498
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x29a0a1(%rip), %rax    # 0x36c498
movl %ecx, (%rax)
callq 0xa0f60
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Aw()
void parse_moto_Aw()
{
u08 x;

   // GPS (0) UTC (1) select
   log_packet_id("timing mode");
   x = tsip_byte();  
   if(x == 0) {
      time_flags &= (~TFLAGS_UTC);
      timing_mode = TMODE_GPS;
      have_timing_mode = 1;
   }
   else {
      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 0xb5b49(%rip), %rdi     # 0x187f58
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0xd2453
leaq 0x29a258(%rip), %rax    # 0x36c684
movl (%rax), %ecx
andl $-0x2, %ecx
leaq 0x29a24c(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
leaq 0x29a25c(%rip), %rax    # 0x36c69d
movb $0x0, (%rax)
leaq 0x29a161(%rip), %rax    # 0x36c5ac
movl $0x1, (%rax)
jmp 0xd247f
leaq 0x29a22a(%rip), %rax    # 0x36c684
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x29a21e(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
leaq 0x29a22e(%rip), %rax    # 0x36c69d
movb $0x3, (%rax)
leaq 0x29a133(%rip), %rax    # 0x36c5ac
movl $0x1, (%rax)
leaq 0x29a12a(%rip), %rax    # 0x36c5b0
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Az()
void parse_moto_Az()
{
S32 val;

   // cable delay
   log_packet_id("cable delay");
   val = tsip_dword();
   cable_delay = ((double) val) / 1.0E9;
// if(have_cable_delay == 0) need_redraw = 2040;
   have_cable_delay = 1;
   show_cable_delay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb5ab5(%rip), %rdi     # 0x187f64
callq 0x7add0
callq 0x7a680
movl %eax, -0x4(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd 0x9cb5f(%rip), %xmm1    # 0x16f028
divsd %xmm1, %xmm0
leaq 0x29aad4(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
leaq 0x299fb5(%rip), %rax    # 0x36c494
movl $0x1, (%rax)
callq 0xa0f60
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Bb()
void parse_moto_Bb()
{
int i;
int nsats;
int prn;
s16 doppler;
int el;
int az;
int health;

   log_packet_id("sat visibility");
   nsats = tsip_byte();
   for(i=0; i<12; i++) {
      prn     = tsip_byte();
      doppler = tsip_word();
      el      = tsip_byte();
      az      = tsip_word();
      health  = tsip_byte();

      if((prn >= 1) && (prn <= MAX_PRN)) { 
         set_sat_azel(prn, (float) az, (float) el);
         sat[prn].doppler = (float) doppler;
         sat[prn].health_flag = health;  // 0=healthy  1=unhealthy
         have_sat_azel = 7;
         if(sat[prn].doppler != 0.0F) {
            if(have_doppler == 0) need_redraw = 2041;
            have_doppler |= rinex_gnss(prn);
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xb5918(%rip), %rdi     # 0x187e37
callq 0x7add0
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0xc, -0x4(%rbp)
jge 0xd265b
callq 0x7a510
movzbl %al, %eax
movl %eax, -0xc(%rbp)
callq 0x7a560
movw %ax, -0xe(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x14(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x18(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0xd264b
cmpl $0x3e7, -0xc(%rbp)      # imm = 0x3E7
jg 0xd264b
movl -0xc(%rbp), %edi
cvtsi2ssl -0x18(%rbp), %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
callq 0x7d450
movswl -0xe(%rbp), %eax
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x1cbbdb(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movsd %xmm0, 0x30(%rax)
movl -0x1c(%rbp), %eax
movb %al, %cl
movslq -0xc(%rbp), %rdx
leaq 0x1cbbbc(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movb %cl, (%rax)
leaq 0x299e8d(%rip), %rax    # 0x36c474
movl $0x7, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1cbb98(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movsd 0x30(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd2614
jp 0xd2614
jmp 0xd2649
leaq 0x299f05(%rip), %rax    # 0x36c520
cmpl $0x0, (%rax)
jne 0xd262d
leaq 0x1a53fd(%rip), %rax    # 0x277a24
movl $0x7f9, (%rax)          # imm = 0x7F9
movl -0xc(%rbp), %edi
callq 0x12d280
movl %eax, %ecx
leaq 0x299ee2(%rip), %rax    # 0x36c520
orl (%rax), %ecx
leaq 0x299ed9(%rip), %rax    # 0x36c520
movl %ecx, (%rax)
jmp 0xd264b
jmp 0xd264d
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd2536
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Bd()
void parse_moto_Bd()
{
u08 valid;
u08 week;
u08 time;
u08 sv_count;
u32 sv_mask;

   // almanac status
   log_packet_id("almanac status");

   valid = tsip_byte();
   week = tsip_byte();
   time = tsip_byte();
   sv_count = tsip_byte();
   sv_mask = tsip_dword();

   tsip_byte();  // reserved bytes
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();

   if(valid) minor_alarms &= (~MINOR_ALMANAC);
   else      minor_alarms |= MINOR_ALMANAC;
   have_almanac = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb58ff(%rip), %rdi     # 0x187f7e
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
callq 0x7a510
movb %al, -0x2(%rbp)
callq 0x7a510
movb %al, -0x3(%rbp)
callq 0x7a510
movb %al, -0x4(%rbp)
callq 0x7a680
movl %eax, -0x8(%rbp)
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
cmpb $0x0, -0x1(%rbp)
je 0xd26f4
leaq 0x299cd7(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xfffff7ff, %ecx       # imm = 0xFFFFF7FF
leaq 0x299cc8(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd270c
leaq 0x299cbd(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
leaq 0x299cae(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x299d71(%rip), %rax    # 0x36c484
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Bj()
void parse_moto_Bj()
{
int leap;

   // get leapscond pending info
   log_packet_id("leapsecond info");
   if(have_moto_Gj) return;  // M12 messes this up, always reports no leap

   leap = tsip_byte();
   if(leap) {
      minor_alarms |= MINOR_LEAP_PEND;
   }
   else { 
      minor_alarms &= (~MINOR_LEAP_PEND);
   }
   have_leap_info = 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb434a(%rip), %rdi     # 0x186a79
callq 0x7add0
leaq 0x299cbd(%rip), %rax    # 0x36c3f8
cmpl $0x0, (%rax)
je 0xd2742
jmp 0xd2792
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xd276d
leaq 0x299c5e(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x80, %ecx
leaq 0x299c4f(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
jmp 0xd2785
leaq 0x299c44(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
leaq 0x299c35(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x299cec(%rip), %rax    # 0x36c478
movl $0x3, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Bo()
void parse_moto_Bo()
{
int i;

   // gps/utc time offset
   log_packet_id("utc offset");
   i = (int) (s08) tsip_byte(); 

   if(!user_set_utc_ofs) {
      utc_offset = i;
      check_utc_ofs(8);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb569d(%rip), %rdi     # 0x187e4c
callq 0x7add0
callq 0x7a510
movsbl %al, %eax
movl %eax, -0x4(%rbp)
leaq 0x29a14e(%rip), %rax    # 0x36c914
cmpl $0x0, (%rax)
jne 0xd27e1
movl -0x4(%rbp), %ecx
leaq 0x29a133(%rip), %rax    # 0x36c908
movl %ecx, (%rax)
movl $0x8, %edi
callq 0x7a270
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Ca()
void parse_moto_Ca()
{
u16 status;

   log_packet_id("self test results");
   status = tsip_word();     // 6 channel self test

   critical_alarms = 0;
   minor_alarms &= (~MINOR_EEPROM);

   if(status & 0x0280) critical_alarms |= CRIT_ROM;   // ROM
   if(status & 0x0500) critical_alarms |= CRIT_RAM;   // RAM
   if(status & 0x1040) critical_alarms |= CRIT_OCXO;  // 1KHz / DCXO
   if(status & 0xE03F) critical_alarms |= CRIT_FPGA;  // FPGA

   if(status & 0x0800) minor_alarms |= MINOR_EEPROM;  // EEPROM
   have_eeprom = 1;
   if(!have_critical_alarms) need_redraw = 7704;
   have_critical_alarms = 4;

   init_messages(24, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb578e(%rip), %rdi     # 0x187f8d
callq 0x7add0
callq 0x7a560
movw %ax, -0x2(%rbp)
leaq 0x299b9c(%rip), %rax    # 0x36c3b0
movl $0x0, (%rax)
leaq 0x299b97(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
leaq 0x299b88(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x280, %eax            # imm = 0x280
cmpl $0x0, %eax
je 0xd2855
leaq 0x299b69(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x299b5d(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x500, %eax            # imm = 0x500
cmpl $0x0, %eax
je 0xd2878
leaq 0x299b46(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x299b3a(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x1040, %eax           # imm = 0x1040
cmpl $0x0, %eax
je 0xd289b
leaq 0x299b23(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x10, %ecx
leaq 0x299b17(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0xe03f, %eax           # imm = 0xE03F
cmpl $0x0, %eax
je 0xd28be
leaq 0x299b00(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x299af4(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xd28e4
leaq 0x299ae5(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
leaq 0x299ad6(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x299ba1(%rip), %rax    # 0x36c48c
movl $0x1, (%rax)
leaq 0x299b90(%rip), %rax    # 0x36c488
cmpl $0x0, (%rax)
jne 0xd290a
leaq 0x1a5120(%rip), %rax    # 0x277a24
movl $0x1e18, (%rax)         # imm = 0x1E18
leaq 0x299b77(%rip), %rax    # 0x36c488
movl $0x4, (%rax)
movl $0x18, %edi
movl $0x1, %esi
callq 0x86290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Fa()
void parse_moto_Fa()
{
u16 status;

   log_packet_id("self test results");
   status = tsip_word();     // 8 channel self test

   critical_alarms = 0;
   minor_alarms &= (~MINOR_EEPROM);

   if(status & 0x0600) critical_alarms |= CRIT_ROM;   // ROM
   if(status & 0x1800) critical_alarms |= CRIT_RAM;   // RAM
   if(status & 0x4100) critical_alarms |= CRIT_OCXO;  // 1KHz / DCXO
   if(status & 0x80FF) critical_alarms |= CRIT_FPGA;  // FPGA

   if(status & 0x2000) minor_alarms |= MINOR_EEPROM;  // EEPROM
   have_eeprom = 1;
   if(!have_critical_alarms) need_redraw = 7705;
   have_critical_alarms = 5;

   init_messages(25, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb47ae(%rip), %rdi     # 0x187f8d
callq 0x7add0
callq 0x7a560
movw %ax, -0x2(%rbp)
leaq 0x298bbc(%rip), %rax    # 0x36c3b0
movl $0x0, (%rax)
leaq 0x298bb7(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
leaq 0x298ba8(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x600, %eax            # imm = 0x600
cmpl $0x0, %eax
je 0xd3835
leaq 0x298b89(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x298b7d(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x1800, %eax           # imm = 0x1800
cmpl $0x0, %eax
je 0xd3858
leaq 0x298b66(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x298b5a(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x4100, %eax           # imm = 0x4100
cmpl $0x0, %eax
je 0xd387b
leaq 0x298b43(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x10, %ecx
leaq 0x298b37(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x80ff, %eax           # imm = 0x80FF
cmpl $0x0, %eax
je 0xd389e
leaq 0x298b20(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x298b14(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movzwl -0x2(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xd38c4
leaq 0x298b05(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
leaq 0x298af6(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x298bc1(%rip), %rax    # 0x36c48c
movl $0x1, (%rax)
leaq 0x298bb0(%rip), %rax    # 0x36c488
cmpl $0x0, (%rax)
jne 0xd38ea
leaq 0x1a4140(%rip), %rax    # 0x277a24
movl $0x1e19, (%rax)         # imm = 0x1E19
leaq 0x298b97(%rip), %rax    # 0x36c488
movl $0x5, (%rax)
movl $0x19, %edi
movl $0x1, %esi
callq 0x86290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Gc()
void parse_moto_Gc()
{
   log_packet_id("pps state");
   pps_enabled = pps_mode = tsip_byte();  // 0=off, 1=always on,  2=on when tracking, 3=on when traim met
   have_pps_enable = 7;
   have_pps_mode = 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb47a6(%rip), %rdi     # 0x188111
callq 0x7add0
callq 0x7a510
movb %al, %cl
leaq 0x299584(%rip), %rax    # 0x36cf02
movb %cl, (%rax)
leaq 0x299579(%rip), %rax    # 0x36cf00
movb %cl, (%rax)
leaq 0x298b2c(%rip), %rax    # 0x36c4bc
movl $0x7, (%rax)
leaq 0x298b2f(%rip), %rax    # 0x36c4cc
movl $0x7, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Gj()
void parse_moto_Gj()
{
u08 present, future;
u16 leap_year;
u08 leap_month;
u16 leap_day;
u08 leap_hour;
u08 leap_min;
u08 leap_sec;
double jd;

   // leapsecond info
   log_packet_id("leapsecond info");
   present = tsip_byte();
   future = tsip_byte();
   leap_year = tsip_word();
   leap_month = tsip_byte();
   leap_day = tsip_byte();

   tsip_byte();
   tsip_dword();

   leap_hour = tsip_byte();
   leap_min = tsip_byte();
   leap_sec = tsip_byte(); 

   if(present != future) {    // leapsecond pending
      minor_alarms |= (MINOR_LEAP_PEND);
      jd = jdate(leap_year, leap_month, leap_day) - 1.0;  // -1 since moto says 2017/1/1
      jd_leap = jd + jtime(23,59,59,0.0);
      have_jd_leap = 3;
      calc_jd_leap(3);

//      jd -= jdate(year, month, day);  // days until leap occurs
//      leap_days = ((int) jd);
//      have_leap_days = 0;
//      if(leap_days >= LEAP_THRESH) leap_days = (-1);
//      else have_leap_days = 2;
//sprintf(plot_title, "pres:%d fut:%d %04d/%02d/%02d   days:%d", present,future,leap_year,leap_month,leap_day, leap_days);
   }
   else {
      minor_alarms &= (~MINOR_LEAP_PEND);
   }

   have_moto_Gj = 1;
   have_leap_info = 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xb302a(%rip), %rdi     # 0x186a79
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
callq 0x7a510
movb %al, -0x2(%rbp)
callq 0x7a560
movw %ax, -0x4(%rbp)
callq 0x7a510
movb %al, -0x5(%rbp)
callq 0x7a510
movzbl %al, %eax
movw %ax, -0x8(%rbp)
callq 0x7a510
callq 0x7a680
callq 0x7a510
movb %al, -0x9(%rbp)
callq 0x7a510
movb %al, -0xa(%rbp)
callq 0x7a510
movb %al, -0xb(%rbp)
movzbl -0x1(%rbp), %eax
movzbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
je 0xd3b3b
leaq 0x2988fe(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x80, %ecx
leaq 0x2988ef(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
movzwl -0x4(%rbp), %edi
movzbl -0x5(%rbp), %esi
movzwl -0x8(%rbp), %edx
callq 0x122140
movsd 0x9b584(%rip), %xmm1    # 0x16f068
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x17, %edi
movl $0x3b, %edx
xorps %xmm0, %xmm0
movl %edx, %esi
callq 0x122210
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
leaq 0x298c22(%rip), %rax    # 0x36c740
movsd %xmm0, (%rax)
leaq 0x298c1f(%rip), %rax    # 0x36c748
movl $0x3, (%rax)
movl $0x3, %edi
callq 0x80070
jmp 0xd3b53
leaq 0x298876(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
leaq 0x298867(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x29889e(%rip), %rax    # 0x36c3f8
movl $0x1, (%rax)
leaq 0x298911(%rip), %rax    # 0x36c478
movl $0x4, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Hn()
void parse_moto_Hn()
{
int i;
S32 sawtooth;
s16 accu;
int traim_flag;
int prn;
u32 frac;

   log_packet_id("traim info");
   if(moto_chans != 12) {
      moto_chans = 12;
      config_msg_ofs();
   }

   tsip_byte();   // pulse
   tsip_byte();   // synced to
   traim_status = tsip_byte();  // timing solution
   traim_flag = tsip_byte();    // traim status
   have_traim = 1;
//sprintf(debug_text2, "traim status:%d", traim_status);
   tsip_dword();  // Traim removed sats vector

   accu = tsip_word();     // time accuracy
   sawtooth = tsip_byte(); // sawtooth
   if(sawtooth & 0x80) sawtooth |= (~(S32)0xFF);
   have_sawtooth = 1;

   dac_voltage = (float) sawtooth;
   pps_offset = (double) accu;
   have_pps_offset = 6;
   have_rcvr_pps = 6;
//adadad   if(jitter_adev == 0) do_pps_adev(pps_offset);

   for(i=0; i<12; i++) {
      prn = tsip_byte();  // prn
      frac = tsip_dword(); // time fraction
      if(frac >= 1000000000) frac = 0;

      if(0 && (prn >= 1) && (prn <= MAX_PRN)) { 
         sat[prn].sat_bias = (float) (((double) frac) * 1.0E-9);
         sat[prn].last_bias_msg = 2;

         if(frac > 0) {
            if(have_bias == 0) need_redraw = 2047;
            have_bias = 2;
         }
      }
   }
//sprintf(debug_text2, "Hn: thresh:%d tmode:%d tstat:%d flag:%d   pps:%d  saw:%d  rate:%d  accu:%d ", 
//traim_threshold,traim_mode,traim_status,traim_flag,   pps_mode,sawtooth,pps_rate,accu);
//sprintf(debug_text, "baud:%d db:%d par:%d stop:%d", baud_rate,com[RCVR_PORT].data_bits,com[RCVR_PORT].parity,com[RCVR_PORT].stop_bits);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xb3f50(%rip), %rdi     # 0x1880cf
callq 0x7add0
leaq 0x1a6079(%rip), %rax    # 0x27a204
cmpl $0xc, (%rax)
je 0xd41a2
leaq 0x1a606d(%rip), %rax    # 0x27a204
movl $0xc, (%rax)
callq 0x63c20
callq 0x7a510
callq 0x7a510
callq 0x7a510
movzbl %al, %ecx
leaq 0x1a60ed(%rip), %rax    # 0x27a2a8
movl %ecx, (%rax)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x10(%rbp)
leaq 0x2983d9(%rip), %rax    # 0x36c5a8
movl $0x1, (%rax)
callq 0x7a680
callq 0x7a560
movw %ax, -0xa(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xd4206
movl -0x8(%rbp), %eax
orl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, -0x8(%rbp)
leaq 0x298397(%rip), %rax    # 0x36c5a4
movl $0x1, (%rax)
cvtsi2ssl -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2979bd(%rip), %rax    # 0x36bbe0
movsd %xmm0, (%rax)
movswl -0xa(%rbp), %eax
cvtsi2sd %eax, %xmm0
leaq 0x297762(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
leaq 0x2981d7(%rip), %rax    # 0x36c418
movl $0x6, (%rax)
leaq 0x2981d6(%rip), %rax    # 0x36c424
movl $0x6, (%rax)
movl $0x0, -0x4(%rbp)
cmpl $0xc, -0x4(%rbp)
jge 0xd4291
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x14(%rbp)
callq 0x7a680
movl %eax, -0x18(%rbp)
cmpl $0x3b9aca00, -0x18(%rbp) # imm = 0x3B9ACA00
jb 0xd4284
movl $0x0, -0x18(%rbp)
jmp 0xd4286
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd425b
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Ia()
void parse_moto_Ia()
{
u08 stat1;
u16 stat2;
u32 status;

   log_packet_id("alarms");

   stat1 = tsip_byte();
   stat2 = tsip_word();

   status = stat1;
   status <<= 16;
   status |= stat2; 

   critical_alarms = 0;
   minor_alarms &= (~MINOR_EEPROM);

   if(status & 0x020000) critical_alarms |= CRIT_ROM;  // ROM
   if(status & 0x040000) critical_alarms |= CRIT_RAM;  // RAM
   if(status & 0x012000) critical_alarms |= CRIT_OCXO; // 1KHz / DCXO
   if(status & 0x000FFF) critical_alarms |= CRIT_FPGA; // FPGA
   if(status & 0x305000) critical_alarms |= CRIT_FPGA; // FPGA

   if(status & 0x000000) minor_alarms |= MINOR_EEPROM; // EEPROM
   have_eeprom = 1;
   if(!have_critical_alarms) need_redraw = 7706;
   have_critical_alarms = 6;

   init_messages(26, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb3c11(%rip), %rdi     # 0x188170
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
callq 0x7a560
movw %ax, -0x4(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x8(%rbp)
movzwl -0x4(%rbp), %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x297e1a(%rip), %rax    # 0x36c3b0
movl $0x0, (%rax)
leaq 0x297e15(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
leaq 0x297e06(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
andl $0x20000, %eax          # imm = 0x20000
cmpl $0x0, %eax
je 0xd45d6
leaq 0x297de8(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x297ddc(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0xd45f8
leaq 0x297dc6(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x297dba(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
andl $0x12000, %eax          # imm = 0x12000
cmpl $0x0, %eax
je 0xd461a
leaq 0x297da4(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x10, %ecx
leaq 0x297d98(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
cmpl $0x0, %eax
je 0xd463c
leaq 0x297d82(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x297d76(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
andl $0x305000, %eax         # imm = 0x305000
cmpl $0x0, %eax
je 0xd465e
leaq 0x297d60(%rip), %rax    # 0x36c3b0
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x297d54(%rip), %rax    # 0x36c3b0
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
andl $0x0, %eax
cmpl $0x0, %eax
je 0xd4681
leaq 0x297d48(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
leaq 0x297d39(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x297e04(%rip), %rax    # 0x36c48c
movl $0x1, (%rax)
leaq 0x297df3(%rip), %rax    # 0x36c488
cmpl $0x0, (%rax)
jne 0xd46a7
leaq 0x1a3383(%rip), %rax    # 0x277a24
movl $0x1e1a, (%rax)         # imm = 0x1E1A
leaq 0x297dda(%rip), %rax    # 0x36c488
movl $0x6, (%rax)
movl $0x1a, %edi
movl $0x1, %esi
callq 0x86290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_moto_Sz()
void parse_moto_Sz()
{
   // power up self test failed
   log_packet_id("power-up test results");

   tsip_byte();

   critical_alarms = CRIT_ALL;  // 0x1F;
   if(!have_critical_alarms) need_redraw = 7707;
   have_critical_alarms = 7;
   minor_alarms = MINOR_ALL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb3a9c(%rip), %rdi     # 0x188177
callq 0x7add0
callq 0x7a510
leaq 0x297cc4(%rip), %rax    # 0x36c3b0
movl $0xffff, (%rax)         # imm = 0xFFFF
leaq 0x297d8f(%rip), %rax    # 0x36c488
cmpl $0x0, (%rax)
jne 0xd470b
leaq 0x1a331f(%rip), %rax    # 0x277a24
movl $0x1e1b, (%rax)         # imm = 0x1E1B
leaq 0x297d76(%rip), %rax    # 0x36c488
movl $0x7, (%rax)
leaq 0x297c99(%rip), %rax    # 0x36c3b8
movl $0xffff, (%rax)         # imm = 0xFFFF
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: skip_moto_msg()
void skip_moto_msg()
{
   log_packet_id("ignored message");
   while(moto_msg_len > 0) {
      tsip_byte();
      --moto_msg_len;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb3a52(%rip), %rdi     # 0x18818d
callq 0x7add0
cmpl $0x0, 0x2f7561(%rip)    # 0x3cbca8
jle 0xd475f
callq 0x7a510
movl 0x2f7554(%rip), %eax    # 0x3cbca8
addl $-0x1, %eax
movl %eax, 0x2f754b(%rip)    # 0x3cbca8
jmp 0xd4740
popq %rbp
retq
nopw %cs:(%rax,%rax)